CLIProxyAPI Transform Your AI Subscriptions into Universal API Endpoints

Jan 4, 2026

CLIProxyAPI: Transform Your AI Subscriptions into Universal API Endpoints

Introduction

In the rapidly evolving landscape of AI coding tools, developers often face a fragmentation problem: premium subscriptions are locked behind OAuth authentication, while many tools and SDKs expect standard API keys. CLIProxyAPI elegantly solves this bridge by converting OAuth-based AI services into universal API endpoints.

CLIProxyAPI

What is CLIProxyAPI?

CLIProxyAPI is an open-source proxy server written in Go that wraps multiple AI CLI tools and exposes them through standardized API interfaces. It transforms your existing AI subscriptions into OpenAI/Gemini/Claude-compatible APIs, eliminating the need for separate API keys.

Project: router-for-me/CLIProxyAPI License: MIT Language: Go (99.7%)

Key Features and Highlights

1. Multi-Provider OAuth Integration

CLIProxyAPI supports OAuth authentication for leading AI services:

Claude Code - Anthropic’s Claude models via OAuth
ChatGPT / OpenAI Codex - GPT series models
Gemini CLI - Google’s Gemini models
Qwen Code - Alibaba’s Qwen models
iFlow - Additional AI service support
Antigravity - Alternative AI provider

2. Universal API Compatibility

The proxy provides standardized endpoints compatible with:

OpenAI API format
Gemini API format
Claude API format
Codex API format

This means your existing OpenAI SDK code works without modification—just change the base URL.

3. Advanced Account Management

Multi-account support with round-robin load balancing
Hot reload configuration changes take effect without restart
OAuth session management with automatic token refresh
Model mapping for intelligent fallback (e.g., claude-opus-4.5 → claude-sonnet-4)

4. Comprehensive Feature Set

Streaming and non-streaming responses
Function calling / tools support
Multimodal input (text and images)
Management API for runtime configuration
Reusable Go SDK for embedding
Docker containerization support

Prerequisites, Installation and Configuration

System Requirements

Go 1.21+ (for building from source)
Docker (optional, for containerized deployment)
Valid subscriptions for supported AI services

Installation Methods

Method 1: Build from Source

git clone https://github.com/router-for-me/CLIProxyAPI.git
cd CLIProxyAPI
go build -o cliproxyapi cmd/server/main.go
./cliproxyapi

Method 2: Docker Deployment

docker run -d -p 8080:8080 router-for-me/cliproxyapi:latest

Method 3: Pre-built Binaries

Download from the Releases page (393 releases available).

Quick Configuration

Configure OAuth Providers

Edit the configuration file to add your OAuth accounts:

providers:
  claude:
    type: oauth
    accounts:
      - email: "your@email.com"
        # OAuth flow will prompt for authentication

  gemini:
    type: oauth
    accounts:
      - email: "your@gmail.com"

  openai:
    type: oauth
    accounts:
      - email: "your@outlook.com"

Start the Server

./cliproxyapi --config config.yaml

Use Standard OpenAI SDK

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="any-key-ignored"  # OAuth handles auth
)

response = client.chat.completions.create(
    model="claude-opus-4.5",
    messages=[{"role": "user", "content": "Hello!"}]
)

Recommended Scenarios and Best Practices

Use Case 1: AI Coding Tool Integration

Use your Claude Code or ChatGPT subscription with tools that only support API keys:

Claude Code desktop app
Cline VS Code extension
Roo Code assistant
Continue.dev autopilot

Use Case 2: Multi-Account Load Balancing

Distribute requests across multiple accounts to maximize usage limits:

load_balancing:
  strategy: round_robin
  accounts:
    - account1@example.com
    - account2@example.com
    - account3@example.com

Use Case 3: Cost Optimization

Leverage free-tier subscriptions from multiple providers:

Google Gemini (free tier available)
Claude Code subscription
OpenAI ChatGPT Plus

Best Practices

Security First: Management endpoints are localhost-only by design
Model Fallback: Configure intelligent model mapping for availability
Monitor Usage: Use the Management API to track account quotas
Hot Reload: Modify configuration without service interruption

CLIProxyAPI has inspired a rich ecosystem of companion tools:

Project	Description
vibeproxy	Native macOS menu bar app for Claude Code & ChatGPT
ProxyPal	macOS GUI for managing CLIProxyAPI configuration
Quotio	Menu bar app with quota tracking and auto-failover
CodMate	SwiftUI app for CLI AI session management
Subtitle Translator	Browser-based subtitle translation tool

Comparison with Similar Tools

vs. Direct API Keys

Aspect	CLIProxyAPI	Direct API Keys
Cost	Uses existing subscriptions	Separate billing
Authentication	OAuth (no keys to manage)	API key management
Multi-provider	Unified endpoint	Separate SDKs needed
Load balancing	Built-in	Manual implementation

vs. Other Proxy Solutions

Feature	CLIProxyAPI	Alternatives
OAuth Providers	6+ supported	Usually 1-2
Open Source	MIT License	Often proprietary
Go SDK	Embeddable	Standalone only
Documentation	English + Chinese	English only

Precautions, FAQ and Troubleshooting

Common Issues

Q: OAuth token expires frequently

A: CLIProxyAPI handles automatic token refresh. Ensure your OAuth credentials are valid and check system time synchronization.

Q: Model not available

A: Use model mapping to route unavailable models to alternatives:

model_mappings:
  claude-opus-4.5: claude-sonnet-4

Q: Rate limiting errors

A: Enable multi-account load balancing to distribute requests across accounts.

Security Considerations

Management API endpoints bind to localhost only
OAuth tokens are stored securely
Never expose your proxy to public internet without authentication
Regular audit logs track all API requests

Troubleshooting Tips

Check logs: tail -f cliproxyapi.log
Verify OAuth sessions via Management API
Test with simple curl command first
Ensure firewall allows localhost communication

Reference Links

GitHub Repository: https://github.com/router-for-me/CLIProxyAPI
Documentation: https://help.router-for.me/
Management API: https://help.router-for.me/management/api
Chinese README: README_CN.md
Community Guides: linux.do tutorials

Conclusion

CLIProxyAPI represents a pragmatic solution to AI service fragmentation, transforming OAuth-based subscriptions into universal API endpoints. Whether you’re integrating with coding tools, balancing load across accounts, or simply avoiding API key management, CLIProxyAPI provides a robust, open-source foundation.

With active development (1,239+ commits), comprehensive documentation in both English and Chinese, and a growing ecosystem of companion tools, CLIProxyAPI is poised to become an essential utility in the AI developer’s toolkit.

Cover Image Source: CLIProxyAPI GitHub

Publication Summary - 2026-01-04

Blog post successfully created and published about CLIProxyAPI, covering:

Multi-provider OAuth integration (Claude, Gemini, ChatGPT, Qwen, iFlow)
Universal API compatibility with OpenAI/Gemini/Claude formats
Multi-account load balancing and management features
Installation via source, Docker, or pre-built binaries
Ecosystem of related projects (vibeproxy, ProxyPal, Quotio, CodMate)
Security considerations and troubleshooting guide

Status: Published to bilingual blog (English/Chinese)

CodMate: The Ultimate macOS Session Manager for CLI AI Tools

Jan 4, 2026

Vibe Sparking

Introduction

If you’re a developer who uses CLI-based AI tools like Claude Code, Codex, or Gemini CLI, you know the pain of managing hundreds of scattered session files. Finding that brilliant solution from last Tuesday, resuming a suspended project context, or even just reviewing what you accomplished can be frustrating.

Enter CodMate—a native macOS SwiftUI application that brings order to your AI coding chaos. Built with performance in mind and designed for developers who value their time, CodMate transforms how you interact with your AI programming assistants.

What is CodMate?

CodMate is a session manager for CLI AI tools that provides:

Multi-source session browsing supporting Codex, Claude Code, and Gemini CLI
Blazing-fast search with incremental indexing and caching
Compact three-column UI designed for efficient workflow
“Ship it” workflows like Project Review with Git Changes
One-click Resume/New functionality

Built with Swift 6 and SwiftUI, CodMate leverages macOS 13.5+ APIs to deliver a truly native experience with universal binary support (Apple Silicon + Intel).

Key Features

CodMate’s global search panel (⌘F) offers scoped search with progress/cancel capabilities, plus quick list filtering. The app uses:

Memory-mapped reads for fast path indexing
Incremental parsing (first ~64 lines + tail sampling)
Background enrichment with constrained task groups
Chunked full-text search (128 KB) that avoids loading entire files

Project & Task Organization

Keep your work organized with:

Projects that group sessions by repository
Tasks that group sessions by goal
Shareable task context files for team collaboration
Auto-assignment for new sessions in active projects

Terminal Integration

Resume sessions directly into your preferred terminal:

Terminal.app
iTerm2
Warp
Embedded terminal (non-sandbox builds)

Project Review (Git Changes)

One of CodMate’s most powerful features is the Project Review mode, which shows:

Changed files with stage/unstage support
Unified diff or raw preview
Commit UI with AI-powered commit message generation
On-demand repo authorization

MCP Server Management

CodMate includes comprehensive MCP server support:

Uni-Import (paste/drag JSON configuration)
Per-server enable toggles
Per-target toggles (Codex/Claude/Gemini)
Connectivity testing
Automatic export to ~/.claude/settings.json

Installation

Download

Latest version: 0.4.2

Download for Apple Silicon | Download for Intel Mac

Prerequisites

macOS 13.5 or later
Swift 6 toolchain
Xcode Command Line Tools
Your preferred AI CLI (Codex / Claude / Gemini) installed

Architecture & Performance

CodMate is built with clean architecture principles:

├── models/          # Data models (pure types)
├── services/        # IO + indexing + integrations
├── views/           # SwiftUI views (no business logic)
├── utils/           # Helper utilities
├── payload/         # Bundled presets
├── notify/          # CLI helper (codmate-notify)
└── SwiftTerm/       # Embedded terminal dependency

Performance highlights:

Persistent SQLite index for fast launches
Actor-based services for safe concurrency
Cancel-able tasks with proper cancellation guards
File IO prefers memory-mapped data and chunked reads

Keyboard Shortcuts

Shortcut	Action
⌘,	Settings
⌘F	Global Search
⌘R	Refresh
⌘1	Toggle sidebar
⌘2	Toggle session list

Comparison with Alternatives

Feature	CodMate	Terminal-only	Web-based alternatives
Native macOS performance	✅	✅	❌
Multi-CLI support	✅	❌	✅
Visual session browsing	✅	❌	✅
Project organization	✅	❌	Partial
Git integration	✅	❌	Partial
Offline-first	✅	✅	❌
Privacy (local-only)	✅	✅	❌

Use Cases

1. Finding That Perfect Solution

You remember generating a brilliant algorithm solution last week, but can’t recall which session it was in. With CodMate:

Press ⌘F for global search
Type a keyword from the solution
Results appear instantly with context snippets
Click to view the full conversation

2. Project Continuity

Starting a new workday on a project:

Open CodMate and select your project from the sidebar
See all related sessions grouped by task
Review yesterday’s progress in the timeline
One-click Resume to continue exactly where you left off

3. Code Review Before Commit

Ready to commit your AI-assisted changes:

Open Project Review mode
See all changed files with diffs
Stage/unstage as needed
Use AI to generate a descriptive commit message
Commit without leaving the app

Precautions & Limitations

Known Limitations

macOS-only: No Windows or Linux support currently planned
CLI dependency: Requires the underlying CLI tools to be installed separately
Sandbox considerations: Some features (embedded terminal, direct file access) are limited in sandboxed builds

Storage Locations

Understanding where CodMate stores data:

~/.codmate/
├── projects/           # Project metadata
├── tasks/              # Task metadata
├── notes/              # Session renames/comments
├── providers.json      # Custom provider registry
├── mcp-servers.json    # MCP server configuration
└── sessionIndex-v4.db  # SQLite index cache

FAQ

Q: Does CodMate modify my session files?

A: No, CodMate only reads session files. Notes, project assignments, and other metadata are stored separately.

Q: Can I use CodMate with multiple CLI tools simultaneously?

A: Yes! CodMate supports Codex, Claude Code, and Gemini CLI concurrently.

Q: Is my session data sent anywhere?

A: CodMate is local-first. Your session data never leaves your Mac unless you explicitly use features that call external APIs (like AI commit message generation).

Q: How does CodMate handle large session files?

A: CodMate uses intelligent parsing—reading only what’s needed for display, with background enrichment for full content. This keeps the UI fast even with thousands of sessions.

Development & Contributing

CodMate is open source under the Apache-2.0 license:

Repository: github.com/loocor/codmate
License: Apache-2.0
Build: SwiftPM-only, no Xcode project required
Language: Swift 99.1%

Building from Source

# Clone the repository
git clone https://github.com/loocor/codmate.git
cd codmate

# Build and run
make run

# Create distributable app bundle
make app VER=1.0.0

# Create notarized DMG
make dmg VER=1.0.0

Conclusion

CodMate fills a crucial gap in the AI programming workflow by providing a professional-grade interface for managing the hundreds or thousands of conversations we have with our AI assistants. If you live in the terminal with Claude Code, Codex, or Gemini CLI, CodMate is the tool that brings order to the chaos—letting you focus on building rather than hunting for that one perfect response from last week.

Reference Links

Official Site: umate.ai/codmate
GitHub Repository: github.com/loocor/codmate
Releases: GitHub Releases
License: Apache-2.0

Agent Client: AI Coding Agents Directly in Your Obsidian Vault

Jan 4, 2026

Vibe Sparking

Introduction

Agent Client is an Obsidian plugin that brings AI coding agents directly into your knowledge management workspace. Built on the Agent Client Protocol (ACP)—an open standard pioneered by the Zed editor—this plugin creates a seamless bridge between your personal knowledge base and powerful AI coding assistants like Claude Code, Codex, and Gemini CLI.

Agent Client Demo

Instead of juggling between your notes and terminal, Agent Client integrates AI agents into a dedicated right-side panel within Obsidian, transforming your vault into an intelligent development companion.

Key Features and Highlights

🤖 Direct Agent Integration

Chat with AI coding agents in a dedicated right-side panel without leaving Obsidian. Your AI assistant is just a side panel away.

📝 Note Mentions

Reference your Obsidian notes directly in conversations using @notename syntax. Automatically include the active note’s content or manually reference specific notes to provide context to your AI agent.

⚡ Slash Commands

Quickly trigger agent actions using / commands. Browse and execute actions provided by your current agent without typing full prompts.

🔄 Multi-Agent Support

Switch between Claude Code, Codex, Gemini CLI, and any ACP-compatible custom agents. Configure multiple agents and switch between them based on your task requirements.

🎛️ Mode & Model Selection

Change AI models (e.g., Sonnet, Haiku, Opus) and agent modes (e.g., Plan Mode) directly from the chat interface using convenient dropdown menus.

💻 Terminal Integration

Let your agent execute shell commands and return results inline in the chat. Run build scripts, git commands, or any terminal operation without leaving the conversation.

🖼️ Image Attachments

Paste or drag-and-drop images directly into the chat to send them with your message—perfect for visual debugging or UI-related questions.

🔐 Permission Management

Fine-grained control over agent actions. Approve or deny file reads, edits, and command executions based on your comfort level.

Supported Agents

Agent	Provider	Integration Method
Claude Code	Anthropic	via Zed’s SDK adapter (`@zed-industries/claude-code-acp`)
Codex	OpenAI	via Zed’s adapter (`@zed-industries/codex-acp`)
Gemini CLI	Google	with `--experimental-acp` option
Custom	Various	Any ACP-compatible agent (e.g., OpenCode, Qwen Code)

Prerequisites and Installation

Prerequisites

Obsidian: A recent version of Obsidian installed
Node.js: Required for npm-based agents (Claude Code, Codex, Gemini CLI)
- Download from nodejs.org
- Install the LTS version (recommended)

Installation

Method 1: Via BRAT (Recommended)

The plugin is currently awaiting approval for the Obsidian Community Plugins listing. Until then, BRAT is the recommended installation method.

Install the BRAT plugin from the Community Plugins browser
In Obsidian settings, navigate to Community Plugins → BRAT → Add Beta Plugin

Paste this repository URL:

https://github.com/RAIT-09/obsidian-agent-client

BRAT will download the latest release and keep it auto-updated
Enable Agent Client from the plugin list

Method 2: Manual Installation

Download the latest release files from GitHub Releases:
- main.js
- manifest.json
- styles.css
Create the plugin folder: VaultFolder/.obsidian/plugins/agent-client/
Place the downloaded files in this folder
Enable the plugin in Obsidian Settings → Community Plugins

Configuration

Step 1: Install Agent Dependencies

Choose the agents you want to use:

For Claude Code:

npm install -g @zed-industries/claude-code-acp

For Codex:

npm install -g @zed-industries/codex-acp

For Gemini CLI:

npm install -g @google/gemini-cli

Step 2: Find Installation Paths

macOS/Linux:

# Find Node.js path
which node
# Find Claude Code path
which claude-code-acp
# Example output: /usr/local/bin/claude-code-acp

Windows:

# Find Node.js path
where.exe node
# Example output: C:\Program Files\nodejs\node.exe

# Find Claude Code path
where.exe claude-code-acp
# Example output: C:\Users\Username\AppData\Roaming\npm\claude-code-acp.cmd

Step 3: Configure Plugin Settings

Open Settings → Agent Client
Configure your Node.js path with the absolute path found above
Configure your preferred agents:
- Path: Enter absolute path
- API key: Optional if already logged in to the respective account

Example Configuration (macOS/Linux):

Settings:
├── Node.js path: /usr/local/bin/node
├── Claude Code
│   ├── Path: /usr/local/bin/claude-code-acp
│   └── API key: (optional - uses Anthropic account)
├── Codex
│   ├── Path: /usr/local/bin/codex-acp
│   └── API key: (optional - uses OpenAI account)
└── Gemini CLI
    ├── Path: /usr/local/bin/gemini
    └── API key: (optional - uses Google account)

Recommended Scenarios and Best Practices

Daily Workflow Integration

Code Review with Context: Open your project documentation in Obsidian, reference it with @notename, and ask Claude Code to review your implementation against the documented requirements.
Debugging Session: When stuck on a bug, take a screenshot, paste it into the Agent Client chat, and let your AI agent analyze the error while you reference relevant error logs stored in your vault.
Documentation Generation: As you build features, use the chat to generate documentation while the agent reads your code files—then save the output directly to your notes.
Multi-Agent Task Switching: Use Claude Code for architectural planning, switch to Codex for code generation, and use Gemini CLI for alternative perspectives—all within the same interface.

Best Practices

Organize Notes by Project: Structure your vault so that project-specific notes can be easily referenced with @notename
Use Chat Export: Save important conversations for future reference—Agent Client supports exporting chat history
Leverage Terminal Integration: Run tests and builds directly from the chat to get immediate feedback
Permission Management: Start with restrictive permissions and gradually grant access as trust builds with the agent

Precautions, FAQ, and Troubleshooting

Precautions

API Key Security: API keys are stored in Obsidian’s plugin settings. Enable vault encryption if storing sensitive keys
Terminal Commands: Agents can execute commands—review permissions carefully before approving
File Editing: Agents can modify files—always review proposed changes before applying

FAQ

Q: Can I use multiple agents simultaneously? A: Currently, you can switch between agents, but future updates will include multi-instance support for running multiple agents simultaneously.

Q: Does this work on mobile? A: The plugin is designed for desktop Obsidian. Mobile support depends on Obsidian’s plugin capabilities on mobile platforms.

Q: Can I use custom agents? A: Yes! Any agent that implements the Agent Client Protocol (ACP) can be configured in the plugin settings.

Troubleshooting

Issue: Agent fails to start

Verify Node.js path is correct
Check that the agent is installed globally and accessible via which or where.exe
Ensure the agent executable has proper permissions

Issue: Images not sending

Check image format (PNG, JPG supported)
Verify image size is reasonable (< 10MB recommended)

Issue: Terminal commands not working

Approve terminal permissions when prompted
On Windows, consider using WSL mode for better Unix compatibility

Comparison with Similar Tools

Feature	Agent Client (Obsidian)	VS Code + Claude Code	Cursor AI	Zed Editor
Knowledge Base Integration	✅ Native (Obsidian notes)	❌ Limited	❌ Limited	⚠️ Basic
Multi-Agent Support	✅ ACP-compatible	❌ Claude only	❌ Cursor only	✅ ACP-compatible
Terminal Integration	✅ Inline	✅ Native	✅ Native	✅ Native
Note Reference	✅ @notename syntax	❌	❌	⚠️ Basic
Custom Agents	✅ Any ACP agent	❌	❌	✅ Any ACP agent
Platform	macOS/Windows/Linux	Cross-platform	Cross-platform	macOS/Linux

Unique Advantage: Agent Client’s tight integration with Obsidian’s knowledge management makes it ideal for developers who maintain extensive documentation, research notes, or project specifications in their vault.

Roadmap

The developer has planned several exciting features:

Edit Tracking: Automatically follow agent edits—open affected notes and move the cursor as they edit
Chat History Access: Browse, search, and restore previous chat sessions with agents
Multi-Instance Support: Run multiple agents simultaneously in separate panels

Reference Links

Agent Client transforms Obsidian from a passive knowledge repository into an active development companion—where your notes, code, and AI agents work together seamlessly.

Advent of Claude: 31 Days of Claude Code

Jan 4, 2026

Vibe Sparking

Throughout December, I shared one Claude Code tip per day on X/Twitter and LinkedIn. What started as a simple advent calendar became a map of the features that have fundamentally changed how I write software. This post compiles all 31 tips into a comprehensive guide, reorganized from beginner essentials to advanced patterns, and adds additional context that can’t be covered in 280 characters.

Whether you’re just getting started or looking to level up with Claude Code, there’s something here for you.

Getting Started

Before diving into features, set up Claude Code to understand your project.

/init — Let Claude Onboard Itself Onto Your Project

Everybody needs onboarding docs. With /init, Claude writes its own.

Claude reads your codebase and generates a CLAUDE.md file with:

Build and test commands
Key directories and their purposes
Code conventions and patterns
Important architectural decisions

This is the first thing I run in any new project.

For larger projects, you can also create a .claude/rules/ directory for modular, topic-specific instructions. Each .md file in this directory is automatically loaded as project memory alongside your CLAUDE.md. You can even use YAML frontmatter to apply rules conditionally based on file paths:

---
paths: src/api/**/*.ts
---

# API Development Rules

- All API endpoints must include input validation

Think of CLAUDE.md as your general project guide, and .claude/rules/ as focused supplements for testing, security, API design, or anything else that deserves its own file.

Memory Updates

Want to save something to Claude’s memory without manually editing CLAUDE.md? As of Claude Code 2.0.70, just tell Claude to update the Claude.md file for you.

Just tell Claude to remember it:

“Update Claude.md: always use bun instead of npm in this project”

Keep coding without breaking your flow.

@ Mentions — Add Context Instantly

@ mentions are the fastest way to give Claude context:

@src/auth.ts — Add files to context instantly
@src/components/ — Reference entire directories
@mcp:github — Enable/disable MCP servers

File suggestions are ~3x faster in git repositories and support fuzzy matching. @ is the fastest path from “I need context” to “Claude has context.”

Essential Shortcuts

These are the commands you’ll use constantly. Commit them to muscle memory.

The ! Prefix — Run Bash Instantly

Don’t waste tokens asking “can you run git status?”

Just type ! followed by your bash command:

! git status
! npm test
! ls -la src/

The ! prefix executes bash instantly and injects the output into context. No model processing. No delay. No wasted tokens. No need for multiple terminal windows.

This seems small until you realize you’re using it fifty times a day.

Double Esc to Rewind

Want to try a “what if we…” approach without committing to it?

Go wild. If it gets weird, press Esc twice to jump back to a clean checkpoint.

You can rewind the conversation, the code changes, or both. One thing to note here is that Bash commands run cannot be undone.

Your past prompts are searchable:

Key	Action
`Ctrl+R`	Start reverse search
`Ctrl+R` (again)	Cycle through matches
`Enter`	Run it
`Tab`	Edit first

Don’t retype. Recall. This works seamlessly with slash commands too.

Prompt Stashing

It’s like git stash, but for your prompt.

Ctrl+S saves your draft. Send something else. Your draft auto-restores when you’re ready.

No more copying to a scratchpad. No more losing your train of thought mid-conversation.

Prompt Suggestions

Claude can predict what you’ll ask next.

Finish a task, and sometimes you’ll see a grayed-out follow-up suggestion appear:

Key	Action
`Tab`	Accept and edit
`Enter`	Accept and run immediately

Tab used to autocomplete your code. Now it autocompletes your workflow. Toggle this feature via /config.

Session Management

Claude Code is a persistent development environment and optimizing it to your workflow will allow you to do so much more.

Continue Where You Left Off

Accidentally closed your terminal? Laptop died mid-task? No problem.

claude --continue    # Picks up your last conversation instantly
claude --resume      # Shows a picker to choose any past session

Context preserved. Momentum restored. Your work is never lost. You can also customize how long sessions are preserved via the cleanupPeriodDays setting. By default it is 30 days, but you can set it as long as you want, or even 0 if you don’t want to preserve your Claude Code sessions.

Named Sessions

Your git branches have names. Your Claude sessions should too.

/rename api-migration       # Names your current session
/resume api-migration       # Resumes by name
claude --resume api-migration  # Works from the command line too

The /resume screen groups forked sessions and supports keyboard shortcuts: P for preview, R for rename.

Claude Code Remote

Start a task on the web, finish it in your terminal:

# On claude.ai/code, start a Claude Code session
# It runs in the background while you're away

# Later, from your terminal:
claude --teleport session_abc123

This pulls and resumes the session locally. Claude at home and on the go. Also works via the Claude mobile app for iOS and Android, as well as the Claude Desktop app.

/export — Get Receipts

Sometimes you need a record of what happened.

/export dumps your entire conversation to markdown:

Every prompt you sent
Every response Claude gave
Every tool call and its output

Perfect for documentation, training, or proving to your past self that yes, you did already try that approach.

Productivity Features

These features remove friction and help you move faster.

Vim Mode

Tired of reaching for the mouse to edit your prompts?

Type /vim and unlock full vim-style editing:

Command	Action
`h j k l`	Navigate
`ciw`	Change word
`dd`	Delete line
`w b`	Jump by word
`A`	Append at end of line

Edit prompts at the speed of thought. Your muscle memory from decades of vim use finally pays off in an AI tool. And it’s never been easier to exit vim with Claude Code, just type /vim again.

/statusline — Customize Your View

Claude Code has a customizable status bar at the bottom of your terminal.

/statusline lets you configure what appears there:

Git branch and status
Current model
Token usage
Context window percentage
Custom scripts

Information at a glance means fewer interruptions to check on things manually.

/context — X-Ray Vision for Tokens

Ever wonder what’s eating your context window?

Type /context to see exactly what’s consuming your tokens:

System prompt size
MCP server prompts
Memory files (CLAUDE.md)
Loaded skills and agents
Conversation history

When your context starts filling up, this is how you figure out where it’s going.

/stats — Your Usage Dashboard

2023: "Check out my GitHub contribution graph"
2025: "Check out my Claude Code stats"

Type /stats to see your usage patterns, favorite models, usage streaks, and more.

Orange is the new green.

/usage — Know Your Limits

“Am I about to hit my limit?”

/usage        → Check your current usage with visual progress bars
/extra-usage  → Purchase additional capacity

Know your limits. Then exceed them.

Thinking & Planning

Control how Claude approaches problems.

Ultrathink

Trigger extended thinking on demand with a single keyword:

> ultrathink: design a caching layer for our API

When you include ultrathink in your prompt, Claude allocates up to 32k tokens for internal reasoning before responding. For complex architectural decisions or tricky debugging sessions, this can be the difference between a surface-level answer and genuine insight.

In the past you were able to specify think, think harder, and ultrathink to allocate different amounts of tokens for thinking, but we’ve since simplified this into a single thinking budget. The ultrathink keyword only works when MAX_THINKING_TOKENS is not set. When MAX_THINKING_TOKENS is configured, it takes priority and controls the thinking budget for all requests.

Plan Mode

Clear the fog of war first.

Press Shift+Tab twice to enter Plan mode. Claude can:

Read and search your codebase
Analyze architecture
Explore dependencies
Draft implementation plans

But it won’t edit anything until you approve the plan. Think twice. Execute once.

I default to plan mode 90% of the time. The latest version lets you provide feedback when rejecting plans, making iteration faster.

Extended Thinking (API)

When using the Claude API directly, you can enable extended thinking to see Claude’s step-by-step reasoning:

thinking: { type: "enabled", budget_tokens: 5000 }

Claude shows its reasoning in thinking blocks before responding. Useful for debugging complex logic or understanding Claude’s decisions.

Permissions & Safety

Power without control is just chaos. These features let you set boundaries.

Sandbox Mode

"Can I run npm install?" [Allow]
"Can I run npm test?" [Allow]
"Can I cat this file?" [Allow]
"Can I pet that dawg?" [Allow]
×100

/sandbox lets you define boundaries once. Claude works freely inside them.

You get speed with actual security. The latest version supports wildcard syntax like mcp__server__* for allowing entire MCP servers.

YOLO Mode

Tired of Claude Code asking permission for everything?

claude --dangerously-skip-permissions

This flag says yes to everything. It has “danger” in the name for a reason—use it wisely, ideally in isolated environments or for trusted operations.

Hooks

Hooks are shell commands that run at predetermined lifecycle events:

PreToolUse / PostToolUse: Before and after tool execution
PermissionRequest: Automatically approve or deny permission requests
Notification: React to Claude’s notifications
SubagentStart / SubagentStop: Monitor agent spawning

Configure them via /hooks or in .claude/settings.json.

Use hooks to block dangerous commands, send notifications, log actions, or integrate with external systems. It’s deterministic control over probabilistic AI.

Automation & CI/CD

Claude Code works beyond interactive sessions.

Headless Mode

You can use Claude Code as a powerful CLI tool for scripts and automation:

claude -p "Fix the lint errors"
claude -p "List all the functions" | grep "async"
git diff | claude -p "Explain these changes"
echo "Review this PR" | claude -p --json

AI in your pipeline. The -p flag runs Claude non-interactively and outputs directly to stdout.

Commands — Reusable Prompts

Save any prompt as a reusable command:

Create a markdown file, and it becomes a slash command that can additionally accept arguments:

/daily-standup              → Run your morning routine prompt
/explain $ARGUMENTS         → /explain src/auth.ts

Stop repeating yourself. Your best prompts deserve to be reusable.

Browser Integration

Claude Code can see and interact with your browser.

Claude Code + Chrome

Claude can now directly interact with Chrome:

Navigate pages
Click buttons and fill forms
Read console errors
Inspect the DOM
Take screenshots

“Fix the bug and verify it works” is now one prompt. Install the Chrome extension from claude.ai/chrome.

Advanced: Agents & Extensibility

This is where Claude Code becomes truly powerful.

Subagents

Santa doesn’t wrap every gift himself. He has elves.

Subagents are Claude’s elves. Each one:

Gets its own 200k context window
Performs specialized tasks
Runs in parallel with others
Merges output back to the main agent

Delegate like Santa. Subagents can run in the background while you continue working, and they have full access to MCP tools.

Agent Skills

Skills are folders of instructions, scripts, and resources that teach Claude specialized tasks.

They’re packaged once and usable everywhere. And since Agent Skills are now an open standard, they work across any tool that supports them.

Think of skills as giving Claude expertise on demand. Whether that’s your company’s specific deployment process, a testing methodology, or a documentation standard.

Plugins

Remember when sharing your Claude Code setup meant sending 47 files across 12 directories?

That era is over.

/plugin install my-setup

Plugins bundle commands, agents, skills, hooks, and MCP servers into one package. Discover new workflows via the marketplace, which includes search filtering for easier discovery.

Language Server Protocol (LSP) Integration

Language Server Protocol (LSP) support gives Claude IDE-level code intelligence:

LSP integration provides:

Instant diagnostics: Claude sees errors and warnings immediately after each edit
Code navigation: go to definition, find references, and hover information
Language awareness: type information and documentation for code symbols

Claude Code now understands your code the way your IDE does.

Claude Agent SDK

The same agent loop, tools, and context management that power Claude Code are now available as an SDK. Build agents that work like Claude Code in as little as 10 lines of code:

import { query } from '@anthropic-ai/claude-agent-sdk';

for await (const msg of query({
  prompt: "Generate markdown API docs for all public functions in src/",
  options: {
    allowedTools: ["Read", "Write", "Glob"],
    permissionMode: "acceptEdits"
  }
})) {
  if (msg.type === 'result') console.log("Docs generated:", msg.result);
}

This is just the beginning.

Quick Reference

Keyboard Shortcuts

Shortcut	Action
`!command`	Execute bash immediately
`Esc Esc`	Rewind conversation/code
`Ctrl+R`	Reverse search history
`Ctrl+S`	Stash current prompt
`Shift+Tab` (×2)	Toggle plan mode
`Alt+P` / `Option+P`	Switch model
`Ctrl+O`	Toggle verbose mode
`Tab` / `Enter`	Accept prompt suggestion

Essential Commands

Command	Purpose
`/init`	Generate CLAUDE.md for your project
`/context`	View token consumption
`/stats`	View your usage statistics
`/usage`	Check rate limits
`/vim`	Enable vim mode
`/config`	Open configuration
`/hooks`	Configure lifecycle hooks
`/sandbox`	Set permission boundaries
`/export`	Export conversation to markdown
`/resume`	Resume a past session
`/rename`	Name current session
`/theme`	Open theme picker
`/terminal-setup`	Configure terminal integration

CLI Flags

Flag	Purpose
`-p "prompt"`	Headless/print mode
`--continue`	Resume last session
`--resume`	Pick a session to resume
`--resume name`	Resume session by name
`--teleport id`	Resume a web session
`--dangerously-skip-permissions`	YOLO mode

Closing Thoughts

When I started this advent calendar, I thought I was just sharing tips. But looking back at these 31 days, I see something more: a philosophy of human-AI collaboration.

The best features in Claude Code are about giving you control. Plan mode. Agent Skills. Hooks. Sandbox boundaries. Session management. These are tools for working with AI, not surrendering to it.

The developers who get the most out of Claude Code aren’t the ones who type “do everything for me.” They’re the ones who’ve learned when to use Plan mode, how to structure their prompts, when to invoke ultrathink, and how to set up hooks that catch mistakes before they happen.

AI is a lever. These features help you find the right grip.

Here’s to 2026.

Originally published by Ado Kukic as “Advent of Claude: 31 Days of Claude Code” on adocomplete.com.

Have a favorite Claude Code feature? Let us know on Twitter or open an issue on the Claude Code repository.

Boris Cheny's Claude Code Workflow Revealed: Running 15-20 Opus 4.5 Instances in Parallel

Jan 4, 2026

Vibe Sparking

Boris Cheny’s Claude Code Workflow Revealed: Running 15-20 Opus 4.5 Instances in Parallel

“I’m Boris and I created Claude Code. Lots of people have asked how I use Claude Code, so I wanted to show off my setup a bit.”

— Boris Cherny, January 2, 2026

When the creator of Claude Code shares his personal workflow, the development community pays attention. Boris Cherny recently revealed his surprisingly “vanilla” yet highly sophisticated approach to maximizing AI-assisted development productivity.

Introduction: Compound Thinking and Verification

At the core of Boris’s workflow are two fundamental mindsets:

Compound Thinking - The CLAUDE.md file isn’t a one-time document but a continuously evolving knowledge base accumulated through daily work, code reviews, and problem discovery
Verification Loops - Verification can improve output quality by 2-3x, addressing a core limitation in current AI programming: AI generates code well, but doesn’t inherently know if it actually works or provides good UX

Boris emphasizes: “A good plan is half the success” and invests heavily in upfront planning before switching to auto-accept mode for implementation.

Multi-Instance Parallelism: 15-20 Claude Instances Running Simultaneously

Boris’s workstation runs at least 15 Claude instances concurrently:

Environment	Instances	Purpose
Terminal (iTerm2)	5 tabs	Numbered 1-5, using system notifications for attention management
Browser	5-10 tabs	claude.ai/code sessions
Transport	Bidirectional	Using `&` to transfer local sessions to web, `--teleport` for cross-session movement

This parallel workflow allows Boris to advance multiple tasks simultaneously, effectively orchestrating an intelligence matrix of AI agents.

Model Strategy: Opus 4.5 with Thinking Mode - Exclusively

Boris uses only Opus 4.5 with thinking mode enabled. His rationale is counterintuitive but proven:

“Although Opus is larger and slower, because of its strong understanding and accurate tool usage, it’s actually faster overall. No need for repeated corrections and guidance—it gets it right the first time. That’s true efficiency.”

The upfront cost of larger models pays dividends through reduced iteration cycles and higher-quality first-pass outputs.

Team Knowledge Base: Shared `CLAUDE.md` in Git

The Claude Code team maintains a shared CLAUDE.md file committed to Git that every team member updates weekly. The logic is simple:

“Whenever you see Claude do something wrong, write it into CLAUDE.md. Next time Claude will know not to do that.”

This transforms team coding standards and collective experience into AI-accessible knowledge, creating a flywheel where:

Each code review improves CLAUDE.md
Improved CLAUDE.md automatically raises subsequent code quality
Knowledge compounds over time

Code Review Integration: `@.claude` PR Tags

During code reviews, Boris uses @.claude tags on colleagues’ PRs, instructing Claude to add discovered issues to CLAUDE.md. This is powered by Claude Code’s GitHub Action (installed via /install-github-action).

This is their version of “compound engineering”—every code review systematically improves the knowledge base, which then automatically improves future code quality.

Plan Mode: Discussion Before Implementation

Most sessions start with Plan mode (activated via double Shift+Tab). Boris discusses back and forth with Claude until satisfied with the plan, then switches to auto-accept edit mode where Claude typically completes implementation in one pass.

The pattern reinforces the principle: invest in planning, execute with confidence.

Slash Commands: Automating Inner Loop Workflows

Boris has converted frequently repeated “inner loop” workflows into slash commands stored in .claude/commands/ and committed to Git:

Eliminates repetitive prompt engineering
Claude itself can invoke these commands
Team-wide standardization of workflows
Example: /verify command for validation workflows

Subagents: Common Workflow Automation

Key subagents in Boris’s toolkit:

Subagent	Purpose
code-simplifier	Simplifies code after Claude completes work
verify-app	Contains detailed instructions for end-to-end Claude Code testing

Subagents essentially automate the most common workflows, ensuring every PR runs through standardized quality gates.

Post-Tool-Use Hook: Automatic Code Formatting

The team uses a Post-Tool-Use hook to auto-format Claude-generated code. Since Claude typically generates well-formatted code, the hook only handles the final ~10%, preventing CI format failures while maintaining code style consistency.

Permissions Management: Pre-Allow Rather Than Skip

Boris doesn’t use --dangerously-skip-permissions. Instead, he uses /permissions to pre-allow common, safe bash commands in his environment, avoiding unnecessary permission prompts while maintaining security awareness.

Configuration is stored in .claude/settings.json and shared with the team via Git.

Tool Integration: Slack, BigQuery, Sentry

Claude Code integrates with Boris’s entire toolchain:

Tool	Integration	Use Case
Slack	MCP server	Search and post messages
BigQuery	`bq` CLI	Run queries for analysis
Sentry	Direct integration	Fetch error logs

The Slack MCP configuration (.mcp.json) is also committed to Git for team sharing.

Long-Running Tasks: Background Agents and Stop Hooks

For extended tasks, Boris employs several strategies:

Background agents for verification upon completion
Agent Stop hooks for more deterministic verification
Ralph-Wiggum plugin (originally conceived by Geoffrey Huntley)
Sandbox mode with --permission-mode=dontAsk or --dangerously-skip-permissions for uninterrupted work

The Most Critical Insight: Give Claude Verification Feedback

Boris’s most important insight:

“The most important thing is giving Claude a way to verify its work. With this feedback loop, final result quality improves 2-3x.”

The Claude Code team uses the Claude Chrome extension to test every change. Claude opens the browser, tests the UI, and iterates until code works and user experience is satisfactory.

Verification methods vary by domain—running a bash command, executing test suites, or testing in browser/mobile emulators—but investing in robust verification is universally applicable.

Recommended Scenarios and Best Practices

Daily Workflow Example

1. Start session in Plan mode (Shift+Tab ×2)
2. Discuss approach with Claude until plan solidifies
3. Switch to auto-accept mode for implementation
4. Use verify subagent for testing
5. Run code-simplifier for cleanup
6. If issues found, add learning to CLAUDE.md
7. Commit and repeat

Best Practices

Practice	Benefit
Start with Plan mode	Reduces rework by 50%+
Use Opus 4.5 thinking	Higher quality first-pass output
Invest in verification	2-3x quality improvement
Maintain shared CLAUDE.md	Team knowledge compounds
Automate via slash commands	Consistency across sessions
Code review with @.claude	Continuous knowledge improvement

Precautions and Common Pitfalls

Pitfall	Solution
Skipping verification	Always implement verification feedback loops
Not updating CLAUDE.md	Treat every issue as a learning opportunity
Using smaller models to save tokens	Opus 4.5 is faster overall due to fewer iterations
Solo knowledge silos	Commit CLAUDE.md to Git for team sharing
Ignoring code review learnings	Use @.claude to capture insights automatically

Comparison with Alternative Approaches

Aspect	Boris’s Approach	Traditional AI Coding
Model selection	Opus 4.5 exclusively	Mix of models for cost savings
Planning	Heavy upfront (Plan mode)	Jump straight to coding
Knowledge capture	Systematic (CLAUDE.md)	Ad-hoc or not captured
Verification	Built-in feedback loops	Manual testing only
Team scaling	Shared configs in Git	Individual setups
Parallelism	15-20 instances	1-2 instances

Reference Links

Summary

Boris Cherny’s Claude Code workflow demonstrates that maximum productivity comes from:

Compound thinking - Knowledge accumulates and compounds over time
Verification loops - Quality feedback improves output 2-3x
Opus 4.5 exclusivity - Larger models are faster overall
Parallel execution - 15-20 instances working simultaneously
Shared knowledge bases - Team learning through Git-synced CLAUDE.md

The setup might be “surprisingly vanilla” in configuration, but the methodology represents a sophisticated rethinking of AI-assisted development—transforming from single-shot interactions to a continuously learning, parallel-processing, verification-driven development ecosystem.

“The granularity of productivity has been completely transformed. In the past, we were discussing how to write a good function, while Boris is discussing how to schedule an intelligence matrix composed of 20 Opus 4.5s.”

— 码上盈 | AI陪你做生意

Claude Code in Action: Official Course Review - Master Anthropic's AI CLI

Jan 4, 2026

Vibe Sparking

Introduction

In January 2026, Anthropic released Claude Code in Action — a comprehensive official course designed to teach developers how to harness the full power of Claude Code, their command-line AI assistant. Available on both Anthropic Skilljar and Coursera, this free course bridges the gap between basic AI assistance and professional-grade AI-powered development workflows.

“This course covers Claude Code, a command-line AI assistant that uses language models to perform development tasks.” — Anthropic

Course Overview

What You Get

Format: Free online course with video content
Platform: Anthropic Skilljar / Coursera
Content: 15 lectures, approximately 1 hour of video content
Level: Beginner to intermediate developers
Prerequisites: Basic CLI familiarity and Claude Code access

Course Promise

The course promises to teach you how to:

Use Claude Code’s core tools for file manipulation, command execution, and code analysis
Manage context effectively using /init, CLAUDE.md files, and @ mentions
Control conversation flow with hotkeys and commands
Enable Plan Mode and Thinking Mode for complex tasks
Create custom commands for workflow automation
Extend functionality with MCP servers
Set up GitHub integration for PR reviews
Write custom hooks for behavior extension

Deep Dive: Course Content

1. Understanding Coding Assistants

The course begins by establishing a mental model for how AI coding assistants work:

How LLMs understand and manipulate code
The tool system architecture
Conversation management patterns
Context window considerations

2. Setup and Initial Configuration

Practical guidance on:

Installing Claude Code
API key configuration
Initial setup workflow
Understanding the CLI interface

3. Core Tools Mastery

File Operations:

Reading files with context awareness
Editing code with precision
Searching across codebases
Multi-file operations

Command Execution:

Running shell commands safely
Interpreting command output
Chaining operations
Error handling

Code Analysis:

Understanding code structure
Identifying patterns
Refactoring suggestions
Code review assistance

4. Context Management Strategies

One of the most critical sections covers:

The /init Command:

Automatic project discovery
Generating project documentation
Creating knowledge bases

CLAUDE.md Files:

Project-specific instructions
Team conventions
Coding standards
Architecture documentation

@ Mentions:

Referencing files directly
Scoped context loading
Selective inclusion

5. Conversation Control

Hotkeys and Commands:

Navigation shortcuts
Mode switching
Interruption and resumption
State management

6. Advanced Modes

Plan Mode:

When to use it
How it differs from normal operation
Best practices for planning sessions

Thinking Mode:

Deep analysis workflows
Complex problem-solving
Multi-step reasoning

7. Custom Commands

Creating reusable workflow automation:

Command definition syntax
Parameter handling
Output formatting
Sharing commands across teams

8. MCP Servers Integration

The Model Context Protocol (MCP) ecosystem:

What MCP servers are
Available community servers
Browser automation capabilities
Database integrations
API connections

Popular MCP Servers:

GitHub: PR reviews, issue management
Browser: Web automation, scraping
Database: Query interfaces
FileSystem: Extended file operations

9. GitHub Integration

Automating repository workflows:

Automated PR reviews
Issue triage
Commit message generation
Repository documentation

10. Hooks System

Extending Claude Code behavior:

PreToolUse: Actions before tool execution
PostToolUse: Actions after tool execution
UserPromptSubmit: Prompt processing
Stop: Cleanup on exit

Key Learnings and Insights

1. Context is King

The course emphasizes that effective context management is the single most important skill for using Claude Code productively. The /init command and CLAUDE.md files aren’t conveniences — they’re essential tools.

2. Start Simple, Scale Gradually

Beginners are encouraged to:

Start with basic file operations
Learn core hotkeys first
Gradually adopt advanced features
Build custom commands organically

3. MCP Changes Everything

The MCP ecosystem transforms Claude Code from a capable assistant into an extensible platform. The course provides just a taste of what’s possible with community servers.

4. Hooks Enable Workflow Integration

For teams and power users, hooks are the secret sauce that makes Claude Code fit into existing development workflows seamlessly.

Comparison: Self-Taught vs. Course

Aspect	Self-Taught	After Course
Context Management	Basic file reading	Structured `/init` + `CLAUDE.md`
Commands	Ad-hoc prompts	Reusable custom commands
Integration	Manual copy-paste	MCP + GitHub automation
Workflow	Linear conversations	Hotkey-driven control
Extensibility	Unknown	Hooks fully understood

Who Should Take This Course?

Ideal For:

Developers new to Claude Code
Teams adopting Claude Code
Users who feel they’re underutilizing the tool
Anyone wanting to build custom integrations

Maybe Not For:

Advanced Claude Code users (may be too basic)
Those expecting deep LLM theory (this is practical)
Developers without CLI experience

Practical Takeaways

Immediate Wins

After completing the course, you can immediately:

Set up proper project contexts — Stop pasting code, use /init
Create custom commands — Automate repetitive workflows
Use hotkeys effectively — Control conversations fluidly
Add an MCP server — Extend capabilities
Write a simple hook — Customize behavior

Recommended Next Steps

Practice daily — Use Claude Code for real work
Explore MCP servers — Check MCPmarket
Join the community — Reddit r/ClaudeAI
Build custom commands — Share with your team
Experiment with hooks — Tailor to your workflow

Limitations and Gaps

What the Course Doesn’t Cover

Advanced prompting techniques — Barely touches on prompt engineering
Multi-agent orchestration — No coverage of agent systems
Enterprise deployment — Team scaling strategies absent
Performance optimization — Token management basics only
Advanced MCP patterns — Server creation not covered

Complementary Resources

To fill these gaps, consider:

Claude Code CLI: The Definitive Technical Reference — Deep technical coverage
MCPcat — MCP server guide
Community repositories — Real-world examples and configs

Real-World Application

A Sample Workflow After Taking the Course

# 1. Initialize project context
cd my-project
claude-code /init

# 2. Start a feature task
claude-code
# Prompt: "Add user authentication using /auth-command"

# 3. Use hotkey to enter Plan Mode
# Reviews architecture, creates task list

# 4. Execute with Thinking Mode for complex logic
# Hooks trigger pre-commit checks

# 5. GitHub integration auto-creates PR
# MCP server updates documentation

Conclusion

Claude Code in Action is a well-structured, practical introduction to Anthropic’s AI coding assistant. It won’t make you an expert overnight, but it provides the foundation needed to use Claude Code effectively in professional development workflows.

Value Rating: ⭐⭐⭐⭐☆ (4/5)

Beginners: Essential starting point
Intermediate Users: Good for filling knowledge gaps
Experts: May find it basic

The course is free, takes about an hour, and delivers tangible value. If you’re using Claude Code but feel like you’re missing features, this course will likely unlock capabilities you didn’t know existed.

“The best way to learn Claude Code is to use Claude Code to learn Claude Code.” — Course Philosophy

Sources:

Claude HUD: Real-Time Session Visibility for Claude Code

Jan 4, 2026

Vibe Sparking

TL;DR: Claude HUD by jarrodwatts is a Claude Code plugin that displays real-time session information — context usage, tool activity, agent status, and todo progress — right below your input. No separate window, no tmux required, updates every ~300ms.

Introduction

Have you ever found yourself mid-conversation with Claude Code, wondering:

How much context do I have left?
Which subagent is stuck on what task?
What tools has Claude been using?

Claude HUD answers all these questions at a glance. It’s a heads-up display that shows exactly what’s happening in your Claude Code session, always visible below your input area.

What Exactly is Claude HUD?

Claude HUD is a plugin that extends Claude Code’s statusline API to provide real-time session visibility. It works by:

Reading Claude Code’s native token data (not estimates)
Parsing the transcript for tool/agent activity
Updating the display every ~300ms

Key Insight: Unlike external monitoring tools, Claude HUD uses Claude Code’s built-in statusline API — meaning it works in any terminal, requires no separate window or tmux setup, and displays accurate data directly from the source.

Installation (3 Steps)

Inside a Claude Code instance, run:

# Step 1: Add the marketplace
/plugin marketplace add jarrodwatts/claude-hud

# Step 2: Install the plugin
/plugin install claude-hud

# Step 3: Configure the statusline
/claude-hud:setup

Done! The HUD appears immediately — no restart needed.

What Each Section Shows

Session Info

[Opus 4.5] ████░░░░░░ 19% | 2 CLAUDE.md | 8 rules | 6 MCPs | 6 hooks | ⏱️ 1m

Element	Description
Model	Current model in use (e.g., Opus 4.5, Sonnet 4)
Context bar	Visual meter with color coding (green → yellow → red)
Config counts	Number of CLAUDE.md files, rules, MCPs, and hooks loaded
Duration	How long the session has been running

Tool Activity

✓ TaskOutput ×2 | ✓ mcp_context7 ×1 | ✓ Glob ×1 | ✓ Skill ×1

Running tools show a spinner with the target file
Completed tools aggregate by type with counts

Agent Status

✓ Explore: Explore home directory structure (5s)
✓ open-source-librarian: Research React hooks patterns (2s)

Shows agent type, current task, and elapsed time.

Todo Progress

✓ All todos complete (5/5)

Current task or completion status
Progress counter (completed/total)

Why Real-Time Visibility Matters

Use Case	How Claude HUD Helps
Context management	See your context fill before auto-compaction hits
Agent debugging	Know exactly which subagent is doing what
Performance monitoring	Identify which tools are being called most frequently
Todo tracking	Watch task completion in real-time without asking

Best Practices

1. Context Health Monitoring

Watch the context bar as you work. When it approaches ~80%, consider:

Using /compact focus: "current task" to trim unnecessary history
Checking which files are consuming the most tokens
Asking Claude to summarize long conversations

2. Agent Awareness

When using multi-agent workflows, Claude HUD helps you:

See which agents are running simultaneously
Identify if an agent is stuck (elapsed time keeps growing)
Understand the parallel execution flow

3. Tool Usage Patterns

Over time, you’ll notice patterns:

Which tools you use most frequently
Whether certain operations trigger cascading tool calls
Opportunities to optimize your workflow

Comparison with Other Monitoring Tools

Feature	Claude HUD	`/context`	ccstatusline
Real-time updates	✓ Every ~300ms	Manual command	Every ~1s
Agent tracking	✓	✗	✗
Todo progress	✓	✗	✗
Context breakdown	Bar visual	Detailed segments	Bar visual
Installation	Plugin built-in	Native command	External tool
Terminal requirement	Any terminal	Any terminal	tmux required

Note: These tools complement each other. Use Claude HUD for at-a-glance monitoring and /context for detailed diagnostics.

Requirements

Claude Code v1.0.80+
Node.js 18+ or Bun
Plugin marketplace access

Troubleshooting

HUD not appearing

Verify Claude Code version: claude --version
Run /claude-hud:setup again
Check that the plugin is installed: /plugin list

Context bar seems inaccurate

The bar uses Claude Code’s native token data
Slight variations from billing are expected
Use /context for detailed breakdown

Agents showing “(long time)”

This may indicate a stuck agent
Consider interrupting and retrying the task
Check the agent’s input for potential issues

Technical Details

Architecture

Claude Code → stdin JSON → claude-hud → stdout → displayed in terminal
           ↘ transcript JSONL (tools, agents, todos)

Data Sources

Token data: Native Claude Code statusline API
Tool activity: Parsed from session transcript
Agent status: Task tracking metadata
Todo progress: TodoWrite tool results

Development

git clone https://github.com/jarrodwatts/claude-hud
cd claude-hud
npm ci && npm run build
npm test

See CONTRIBUTING.md for guidelines.

Real-World Impact

Since installing Claude HUD:

Reduced context anxiety: No more surprise compaction
Faster debugging: Can see immediately which agent is stuck
Better session management: Know when to wrap up and summarize

Conclusion

Claude HUD is a small plugin with a big impact: it makes the invisible visible. By showing context usage, tool activity, agent status, and todo progress in real-time, it gives you the situational awareness needed to use Claude Code more effectively.

Whether you’re a heavy user of agents, working with large codebases, or just want better visibility into your sessions, Claude HUD is worth installing.

Install it today:

/plugin marketplace add jarrodwatts/claude-hud
/plugin install claude-hud
/claude-hud:setup

References

Claudian: An Obsidian Plugin That Embeds Claude Code as a Sidebar Chat Interface

Jan 4, 2026

Vibe Sparking

TL;DR: Claudian by YishenTu embeds Claude Code as a sidebar chat interface in Obsidian, giving your vault full agentic capabilities — file read/write, bash commands, vision support, MCP servers, and multi-step workflows — all while seamlessly integrating with your notes.

Introduction

If you’re like me, your Obsidian vault is more than just a note-taking app — it’s your second brain, your project hub, your knowledge base. Now imagine having Claude Code’s full AI agent capabilities integrated directly into that workspace.

That’s exactly what Claudian delivers. It’s an Obsidian plugin that embeds Claude Code as a sidebar chat interface, turning your vault into Claude’s working directory with complete agentic capabilities.

Why this matters: Unlike traditional chatbots or simple AI assistants, Claudian gives Claude actual agency — it can read, write, and edit files in your vault, execute bash commands, use tools, run multi-step workflows, and even connect to external services via MCP. All while staying contextually aware of your notes.

What Exactly is Claudian?

Claudian is an Obsidian plugin built on the Claude Agent SDK that brings Claude Code’s capabilities directly into your Obsidian workspace. Think of it as:

A Sidebar Chat: Click the bot icon or use the command palette to open Claude in a sidebar panel
Full Agentic Power: Claude can read/write files, run bash commands, and execute multi-step workflows within your vault
Context-Aware: Automatically attaches your focused note, lets you @mention files, and includes selected text
Vision Support: Analyze images via drag-drop, paste, or file path
Extensible: Supports slash commands, custom instructions, skills, and MCP servers

Key Insight: This isn’t just a chat interface — it’s Claude Code running inside Obsidian with your vault as its working directory.

Core Features

1. Full Agentic Capabilities

Leverage Claude Code’s complete power within your Obsidian vault:

Capability	Description
File Operations	Read, write, and edit files in your vault
Bash Commands	Execute shell commands with approval safety
Multi-step Workflows	Claude can plan and execute complex tasks
Tool Use	Full access to Claude’s tool ecosystem

2. Context-Aware Chat

Claudian makes Claude contextually aware of your work:

Auto-attach focused note: The note you’re viewing is automatically included as context
@mention files: Type @ to attach other files from your vault
Selection awareness: Selected text is automatically included in conversations
Image support: Drag-drop, paste, or reference images by path
External directories: Configure context paths for read-only access outside your vault
Exclude by tag: Prevent sensitive notes from auto-loading

3. Inline Edit Mode

Select text in your editor and use a hotkey to edit it directly with Claude:

Word-level diff preview shows exactly what changed
Read-only tool access provides context without modifications
Apply changes with a single click

4. Slash Commands

Create reusable prompt templates triggered by /command:

Argument placeholders (e.g., {topic})
@file references for context
Optional inline bash substitutions
Override model and allowed tools per command

5. Instruction Mode (`#`)

Add custom instructions directly from chat input:

Type # to enter instruction mode
Refine system prompts on-the-fly
Review and edit in a modal before saving

6. MCP Support

Connect external tools and data sources via Model Context Protocol:

Transport types: stdio, SSE, HTTP
Context-saving mode: Enable with @server-name
@-mention activation: Trigger MCP servers inline
Claude Code compatible: Share configs with Claude Code

7. Advanced Model Control

Model selection: Haiku, Sonnet, or Opus
Custom models: Configure via environment variables
Thinking budget: Fine-tune extended thinking tokens
Context gauge: Real-time context window usage display

8. Plan Mode

Toggle read-only exploration before implementation:

Press Shift+Tab to enter Plan Mode
Claude explores codebase without making changes
Presents a plan for your approval
Implements after you confirm

9. Robust Security

Permission modes: YOLO (bypass prompts) or Safe (require approval)
Safety blocklist: Block dangerous bash commands
Vault confinement: File tools limited to your vault with symlink-safe checks
Export paths exception: Allow writes to specified directories (e.g., ~/Desktop)

Installation

Option 1: Install from Release (Recommended)

Download the latest release from GitHub Releases
Create a folder called claudian in your vault’s plugins folder:

/path/to/vault/.obsidian/plugins/claudian/

Copy main.js, manifest.json, and styles.css into the folder
Enable in Obsidian: Settings → Community plugins → Enable “Claudian”

Option 2: Install from Source

cd /path/to/vault/.obsidian/plugins
git clone https://github.com/YishenTu/claudian.git
cd claudian
npm install
npm run build

Then enable the plugin in Obsidian settings.

Requirements

Requirement	Details
Claude Code CLI	Must be installed (SDK uses it internally)
Obsidian	Version 1.8.9 or higher
Claude Access	Claude subscription/API or custom provider (OpenRouter, Kimi, GLM, DeepSeek, etc.)
Platform	Desktop only (macOS, Linux, Windows)

Usage

Opening the Chat

Two ways to start chatting:

Click the bot icon in the ribbon
Use the command palette (Cmd/Ctrl + P) and search for “Claudian”

Working with Context

Action	How
Attach current note	Automatically included when chat is open
Attach another file	Type `@` followed by filename
Filter by folder	Type `@folder/` to see files from that directory
Enable MCP server	Type `@server-name` for context-saving MCP
Include selection	Select text before opening chat
Add images	Drag-drop, paste, or type file path

Inline Editing

Select text in your editor
Use the configured hotkey
Claude edits with diff preview
Apply or discard changes

Slash Commands

Type / in the chat input to see available commands. Create new ones in Settings → Slash Commands.

Instruction Mode

Type # to add custom instructions that modify the system prompt for the current session.

Configuration

Key Settings

Setting	Description
Command blocklist	Block dangerous bash commands (default: `rm -rf`, `chmod 777`, etc.)
Allowed export paths	Paths outside vault for file exports (default: `~/Desktop`, `~/Downloads`)
Context paths	External directories for read-only access
Excluded tags	Tags that prevent notes from auto-loading
Media folder	Where vault stores attachments for image embeds
Custom system prompt	Additional instructions appended to default prompt
Permission mode	YOLO (no prompts) or Safe (approval required)
Environment variables	Custom env vars for Claude SDK (KEY=VALUE format)
MCP Servers	Add/edit/test/delete MCP server configurations

Storage

Data is stored in a distributed format (like Claude Code):

vault/.claude/
├── settings.json          # User settings and permissions
├── mcp.json                # MCP server configurations
├── commands/*.md           # Slash commands as Markdown
└── sessions/*.jsonl        # Chat sessions (one per conversation)

.obsidian/plugins/claudian/
├── data.json               # Machine state (active conversation)
└── .claudian-cache/
    └── images/             # Image cache (SHA-256 deduplicated)

Architecture

src/
├── main.ts                      # Plugin entry point
├── core/                        # Core infrastructure
│   ├── agent/                   # Claude Agent SDK wrapper
│   ├── hooks/                   # PreToolUse/PostToolUse hooks
│   ├── images/                  # Image caching and loading
│   ├── mcp/                     # MCP server config management
│   ├── prompts/                 # System prompts for agents
│   ├── sdk/                     # SDK message transformation
│   ├── security/                # Approval, blocklist, path validation
│   ├── storage/                 # Distributed storage system
│   ├── tools/                   # Tool constants and utilities
│   └── types/                   # Type definitions
├── features/                    # Feature modules
│   ├── chat/                    # Main chat view
│   ├── inline-edit/             # Inline edit service
│   ├── mcp/                     # MCP @-mention detection
│   └── settings/                # Settings tab
├── ui/                          # UI components
│   ├── components/              # Input toolbar, dropdowns
│   ├── modals/                  # Approval, inline edit, instruction modals
│   ├── renderers/               # Thinking blocks, tool calls, diffs
│   └── settings/                # Env snippets, MCP settings, slash commands
├── utils/                       # Utility functions
└── style/                       # Modular CSS (→ styles.css)

Security Considerations

Claudian implements several security layers:

Vault Restriction: File tools and Bash commands are limited to the vault directory
Path Validation: Uses realpath to prevent symlink escapes
Command Blocklist: Platform-specific dangerous command patterns
Approval System: Safe mode requires approval per tool call
Export Paths: Write operations to external paths are explicit and configurable
Context Paths: Read-only access to external directories
No Telemetry: No additional tracking beyond your configured API provider

Roadmap

The plugin is actively developed with an extensive roadmap:

Comparison with Alternatives

Feature	Claudian	Copilot	ChatGPT Web
File read/write in vault	✅	❌	❌
Bash command execution	✅	❌	❌
Multi-step workflows	✅	❌	Limited
Context awareness	✅ (Auto)	✅ (Code)	❌
Vision support	✅	✅	✅
Extensible (MCP/Skills)	✅	❌	❌
Custom model support	✅	❌	❌
Works offline	✅	Partial	❌

Getting Started

Install Claude Code CLI if you haven’t already
Install Claudian using one of the methods above
Configure your API key in Claudian settings
Open the chat and try: "Analyze my current note and suggest improvements"
Explore Plan Mode with Shift+Tab for read-only exploration

Conclusion

Claudian represents a significant step forward in AI-assisted knowledge work. By bringing Claude Code’s full agentic capabilities into Obsidian, it transforms your vault from a static note repository into an interactive workspace where Claude can read, write, analyze, and collaborate — all while maintaining deep context awareness of your work.

Whether you’re writing documentation, managing projects, or building a knowledge base, Claudian offers a powerful new way to work with AI that feels natural, integrated, and genuinely useful.

Repository: github.com/YishenTu/claudian

License: MIT

Oh My OpenCode: Claude Code on Steroids - The Ultimate AI Agent Harness

Jan 4, 2026

Vibe Sparking

Introduction

In the rapidly evolving landscape of AI-powered development tools, OpenCode has emerged as a formidable open-source alternative to commercial AI coding assistants. But if you’re a hacker who loves customization and maximum control, Oh My OpenCode is the plugin that transforms OpenCode into something extraordinary.

Created by developer code-yeongyu after spending $24,000 worth of tokens on personal development with various AI tools, Oh My OpenCode represents the distillation of countless hours of testing, configuration, and real-world usage. It’s described by its author as “OpenCode on steroids” — and for good reason.

“If Claude Code does in 7 days what a human does in 3 months, Sisyphus does it in 1 hour. It just works until the task is done. It is a disciplined agent.” — B, Quant Researcher

What is Oh My OpenCode?

Oh My OpenCode is a comprehensive plugin for OpenCode that adds:

Async Subagents — Run multiple AI agents in parallel, just like Claude Code
Curated Agents — Pre-configured specialist agents with optimal models
Crafted Tools — LSP and AST grep tools for powerful code manipulation
Curated MCPs — Built-in Model Context Protocol servers for extended capabilities
Claude Code Compatibility — Full compatibility layer for Claude Code configs

The plugin is battle-tested in production environments and has already helped developers accomplish remarkable feats:

“Knocked out 8000 eslint warnings with Oh My Opencode, just in a day” — Jacob Ferrari

“I converted a 45k line tauri app into a SaaS web app overnight using Ohmyopencode and ralph loop.” — James Hargis

Meet Sisyphus: The Default Agent

At the heart of Oh My OpenCode is Sisyphus, the default orchestrator agent named after the Greek mythological figure condemned to roll a boulder up a hill for eternity.

“In greek mythology, Sisyphus was condemned to roll a boulder up a hill for eternity as punishment for deceiving the gods. LLM Agents haven’t really done anything wrong, yet they too roll their ‘stones’—their thoughts—every single day. My life is no different. Looking back, we are not so different from these agents.”

Sisyphus’s Toolkit

Sisyphus comes equipped with a powerful set of tools and teammates:

Teammates (Curated Agents):

Oracle (GPT 5.2 Medium) — Design and debugging
Frontend UI/UX Engineer (Gemini 3 Pro) — Frontend development
Librarian (Claude Sonnet 4.5) — Official docs and codebase exploration
Explore (Grok Code) — Fast codebase exploration with contextual grep

Built-in Tools:

Full LSP/AstGrep support for decisive refactoring
Todo Continuation Enforcer — Forces agents to finish tasks
Comment Checker — Prevents excessive AI-generated comments
Claude Code Compatibility — Commands, agents, skills, MCPs, and hooks
Curated MCPs: Exa (web search), Context7 (official docs), Grep.app (GitHub search)
Async agents with background execution
Session management and recovery

Key Features

1. Multi-Agent Orchestration

Oh My OpenCode enables sophisticated workflows where different AI models work in parallel:

While Gemini 3 Pro writes the frontend as a background task,
Claude Opus 4.5 handles the backend. Stuck debugging? Call GPT 5.2 for help.
When the frontend reports done, verify and ship.

2. LSP and AST Tools

Unlike other AI harnesses that limit agent access to code analysis, Oh My OpenCode gives agents full access to:

lsp_hover — Type info and documentation
lsp_goto_definition — Jump to symbol definitions
lsp_find_references — Find all usages across workspace
lsp_document_symbols — Get file symbol outline
lsp_workspace_symbols — Search symbols by name
lsp_diagnostics — Get errors before building
lsp_rename — Rename symbols across workspace
ast_grep_search — AST-aware code pattern search
ast_grep_replace — AST-aware code replacement

3. Ralph Loop

Inspired by Anthropic’s Ralph Wiggum plugin, the Ralph Loop is a self-referential development loop that runs until task completion:

/ralph-loop "Build a REST API"

The loop detects <promise>DONE</promise> to know when complete and auto-continues if the agent stops prematurely. It supports all programming languages and can be configured with custom iteration limits.

4. Claude Code Compatibility

Oh My OpenCode provides a comprehensive compatibility layer for Claude Code:

Hooks Integration — PreToolUse, PostToolUse, UserPromptSubmit, Stop
Config Loaders — Commands, Skills, Agents, MCP configs from standard locations
Data Storage — Todo management and transcripts in Claude Code format
Compatibility Toggles — Fine-grained control over which features to enable

5. Context Management

Intelligent context management features:

Context Window Monitor — Alerts at 70%+ usage
Preemptive Compaction — Compacts session at 85% usage (enabled by default)
Anthropic Auto Compact — Automatic summarization at token limits
Tool Output Truncator — Prevents one search from eating your entire context

Installation

Quick Install (Interactive)

bunx oh-my-opencode install
# or use npx if bunx doesn't work
npx oh-my-opencode install

Follow the prompts to configure your Claude, ChatGPT, and Gemini subscriptions.

Agent-Assisted Install

Paste this into a fresh OpenCode session:

Install and configure by following the instructions here
https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/refs/heads/master/README.md

The agent will guide you through the entire setup process.

Configuration

Configuration is stored in JSON/JSONC format:

User config: ~/.config/opencode/oh-my-opencode.json Project config: .opencode/oh-my-opencode.json

Example Configuration

{
  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json",
  "sisyphus_agent": {
    "disabled": false,
    "default_builder_enabled": false,
    "planner_enabled": true,
    "replace_plan": true
  },
  "agents": {
    "oracle": {
      "model": "openai/gpt-5.2"
    },
    "frontend-ui-ux-engineer": {
      "model": "google/gemini-3-pro-high"
    }
  },
  "disabled_hooks": ["startup-toast"],
  "ralph_loop": {
    "enabled": true,
    "default_max_iterations": 100
  }
}

Usage Modes

Keywords for Specialized Modes

Include these keywords in your prompts to activate specialized modes:

ultrawork / ulw — Maximum performance with parallel agent orchestration
search / find — Maximized search effort with parallel explore and librarian agents
analyze / investigate — Deep analysis mode with multi-phase expert consultation

Calling Specialized Agents

Ask @oracle to review this design and propose an architecture
Ask @librarian how this is implemented—why does the behavior keep changing?
Ask @explore for the policy on this feature

Comparison with Claude Code

Feature	Claude Code	Oh My OpenCode
Multi-model support	Claude only	Claude, GPT, Gemini, Grok
Async agents	Yes	Yes
LSP tools	Analysis only	Full refactoring
Hooks	Yes	Yes (compatible)
Custom agents	Skills system	Curated + custom
Extensibility	Limited	Highly extensible
Open source	No	Yes

Best Practices

1. Start Simple

If the configuration seems overwhelming, just remember: include the word ultrawork in your prompt. The agent will figure out the rest.

2. Use Background Agents for Parallel Work

Let different models work on different parts simultaneously:

# Main agent handles backend
# Spawn Gemini 3 Pro for frontend as background task
# Call GPT 5.2 if debugging gets stuck

3. Leverage Context Management

Oh My OpenCode aggressively uses multiple agents to lighten context load. Your agent becomes the dev team lead, and you’re the AI manager.

4. Customize for Your Workflow

You can disable features you don’t need:

{
  "disabled_agents": ["oracle", "frontend-ui-ux-engineer"],
  "disabled_hooks": ["comment-checker"],
  "disabled_mcps": ["context7"]
}

Troubleshooting

Issue: Bunx fails on Ubuntu/Debian

If you installed Bun via Snap, bunx will fail due to sandboxing. Use npx instead or reinstall Bun via the official installer.

Issue: OpenCode version compatibility

Ensure OpenCode version is 1.0.150 or higher:

opencode --version

Issue: Authentication errors

For Google Gemini, consider using the external opencode-antigravity-auth plugin for multi-account load balancing.

FAQ

Q: Do I need all AI subscriptions?

A: No! You can use Oh My OpenCode with just one provider. The plugin supports Claude, ChatGPT, and Gemini, but you pick what you have.

Q: Is this suitable for beginners?

A: The plugin is powerful but can be complex. The author recommends including ultrawork in your prompts — the agent will handle optimization automatically.

Q: How does this compare to AmpCode?

A: Oh My OpenCode is heavily influenced by AmpCode and Claude Code, with features ported and often improved. It’s designed for the open-source OpenCode platform.

Q: Can I use this with existing Claude Code configs?

A: Yes! The Claude Code compatibility layer means your existing configurations, hooks, and skills should work out of the box.

Community and Resources

GitHub Repository: code-yeongyu/oh-my-opencode
OpenCode Documentation: opencode.ai/docs
Video Review: Oh My OpenCode Is Actually Insane
Medium Article: A Deep Dive into Oh My OpenCode
Reddit Community: r/opencodeCLI

Conclusion

Oh My OpenCode represents the culmination of extensive real-world testing and refinement. It transforms OpenCode from a capable AI coding assistant into a sophisticated multi-agent orchestration platform.

Whether you’re a seasoned developer looking to maximize productivity or an AI enthusiast exploring the boundaries of what’s possible, Oh My OpenCode offers a powerful, extensible, and thoroughly tested solution.

As the author puts it:

“Stop agonizing over agent harness choices. I’ll do the research, borrow from the best, and ship updates here.”

Ready to supercharge your OpenCode experience? Install Oh My OpenCode and let Sisyphus keep that boulder rolling.

Sources:

SivaLabs Marketplace: Supercharge Spring Boot Development with Claude Code

Jan 4, 2026

Vibe Sparking

Introduction

Claude Code has rapidly become a powerful AI-powered development companion, and its extensibility through plugins and MCP servers opens up incredible possibilities for specialized development workflows. Enter SivaLabs Marketplace - a curated collection of plugins designed specifically for Java and Spring Boot developers.

Created by K. Siva Prasad Reddy (sivalabs), a well-known Spring Boot author and educator, this marketplace brings enterprise Java development patterns directly into your AI-assisted coding experience.

What is SivaLabs Marketplace?

SivaLabs Marketplace is a plugin collection for Claude Code that focuses on Spring Boot application development using the Java, Spring Boot, and Spring Data JPA technology stack. It provides specialized skills that automate common development tasks while following established best practices and architectural patterns.

The marketplace is currently in active development (as of January 2026) and includes the spring-boot-dev plugin as its flagship offering.

Installation

Getting started with SivaLabs Marketplace is straightforward:

# Add the marketplace to Claude Code
/plugin marketplace add sivaprasadreddy/sivalabs-marketplace

# Enable the marketplace
/plugin enable sivaprasadreddy/sivalabs-marketplace

# Install the Spring Boot development plugin
/plugin install spring-boot-dev@sivalabs-marketplace

After installation, you can verify the plugin and its skills are available using the /plugins command in Claude CLI.

Available Skills

The spring-boot-dev plugin includes five specialized skills that streamline Spring Boot development:

1. spring-boot-package-structure-creator

Creates the recommended package structure for Spring Boot projects following best practices. This skill ensures your project starts with a solid architectural foundation.

2. jpa-entity-creator

Automates the creation of JPA entities with proper annotations, relationships, and best practices. Simply describe your entity requirements, and the skill generates production-ready entity classes.

3. spring-data-jpa-repo-creator

Generates Spring Data JPA repository interfaces for your entities, including custom query methods when needed.

4. spring-service-creator

Creates Spring service layer classes with proper dependency injection, transaction management, and business logic separation.

5. spring-rest-api-creator

Builds Spring MVC REST API controllers with appropriate annotations, request/response handling, and validation.

Practical Example

Here’s how you can use SivaLabs Marketplace to quickly build a CRUD REST API:

Create a Spring Boot project with Web, Validation, Spring Data JPA, and H2 dependencies
In Claude CLI, prompt: “Implement CRUD REST API for Person with id, name, email and phone fields”
The plugin will automatically generate:
- JPA Entity (Person.java)
- Repository interface (PersonRepository.java)
- Service layer (PersonService.java)
- REST Controller (PersonController.java)

Each generated component follows Spring Boot best practices and integrates seamlessly with the others.

Included MCP Server

The marketplace also includes the context7 MCP server, which provides general library documentation lookup capabilities. This enhances Claude Code’s ability to reference official Spring documentation and other libraries during development.

Best Practices and Use Cases

When to Use SivaLabs Marketplace

New Spring Boot Projects: Quickly scaffold properly structured projects
CRUD Operations: Generate standard create, read, update, delete APIs
Learning Spring Boot: See best practices in generated code
Prototyping: Rapidly build working APIs for testing and validation

Tips for Effective Use

Start with Package Structure: Use spring-boot-package-structure-creator first to establish your project layout
Describe Entities Clearly: When using jpa-entity-creator, provide detailed field specifications including types, constraints, and relationships
Review Generated Code: While the plugins follow best practices, always review and adjust generated code to match your specific requirements
Use Context7: Leverage the included MCP server for accessing up-to-date Spring documentation

Comparison with Similar Tools

Feature	SivaLabs Marketplace	Generic AI Coding	Manual Development
Spring Boot Best Practices	✓ Built-in	Variable	Depends on developer
Package Structure	✓ Automated	Often missing	Manual setup
Integration Patterns	✓ Standardized	Inconsistent	Manual implementation
Learning Curve	Low for Spring devs	Varies	High for beginners
Customization	Generated code is editable	Requires prompts	Full control

Precautions and Limitations

Early Development: The marketplace is actively developed; features may evolve
Spring Boot Specific: Not suitable for non-Spring Java projects
Code Review Required: Always review generated code for security, performance, and business logic
Claude Code Dependency: Requires Claude Code CLI environment

Troubleshooting

Plugin Not Found

Ensure the marketplace is added and enabled
Check your internet connection for marketplace access
Verify Claude Code is up to date

Generated Code Issues

Provide more specific prompts with detailed requirements
Review the Spring Boot version compatibility
Check that all required dependencies are in your pom.xml or build.gradle

Future Developments

Given K. Siva Prasad Reddy’s expertise in Spring Boot and his active YouTube channel featuring Spring Boot tutorials, we can expect:

Additional skills for testing (JUnit, Mockito, Testcontainers)
Security configuration generators
Docker and Kubernetes deployment helpers
Integration with other Spring ecosystem projects

Conclusion

SivaLabs Marketplace represents an exciting evolution in AI-assisted Spring Boot development. By combining Claude Code’s powerful AI capabilities with specialized Spring Boot knowledge, it helps developers work faster while maintaining code quality and following established patterns.

Whether you’re a seasoned Spring Boot developer looking to accelerate workflow or a learning developer wanting to see best practices in action, SivaLabs Marketplace is a valuable addition to your Claude Code toolkit.

Reference Links

Sources:

Slash Commands Collection: 13 AI-Powered Developer Productivity Commands

Jan 4, 2026

Vibe Sparking

As AI coding assistants become essential tools for modern developers, the ability to customize and streamline their behavior through slash commands has emerged as a powerful productivity booster. The slash-commands collection by regenrek offers a curated set of 13 battle-tested commands designed specifically for code review, problem analysis, and refactoring workflows. Let’s explore this comprehensive toolkit that works across Claude Code, Cursor, and Codex.

What is the Slash Commands Collection?

The slash-commands repository is a carefully curated collection of AI-powered slash commands created by Kevin Kern, a developer focused on building tools that enhance AI-assisted coding workflows. The collection addresses common pain points developers face when working with AI coding assistants:

Code review consistency - Standardized reviews across team members
Problem diagnosis - Systematic bug identification and impact analysis
Refactoring workflows - Structured approaches to code improvements
Planning and organization - Task management and documentation practices

Each command is designed as a Markdown template that can be invoked with a simple /command-name syntax, making complex workflows repeatable and shareable across teams.

Installation Guide

For Claude Code Users

Claude Code supports both project-specific and personal commands:

Project commands (shared with your team):

mkdir -p .claude/commands
# Copy the .md files to .claude/commands/

Personal commands (available across all projects):

mkdir -p ~/.claude/commands
# Copy the .md files to ~/.claude/commands/

For Cursor Users

mkdir -p .cursor/commands
# Copy the .md files to .cursor/commands/
# Note: Remove the $1 parameters and XML wrapping tags when using in Cursor

For Codex Users

mkdir -p ~/.codex/prompts
# Copy the .md files to ~/.codex/prompts/
# Restart Codex after installation for changes to take effect

Complete Command Reference

1. `/create-plan` - Comprehensive Task Planning

Purpose: Creates structured implementation plans with all necessary sections before development begins.

Usage:

/create-plan TASK="Implement user authentication system"

Features:

Context and problem statement
Measurable success criteria
Clear deliverables and approach
Risk assessment and testing strategy
Cross-references to AGENTS.md for rules/constraints

When to use: At the start of new features or complex tasks to ensure comprehensive planning.

2. `/plan-review` - Implementation Plan Review

Purpose: Reviews implementation plans and provides a go/no-go decision for development.

Usage:

/plan-review "We're planning to implement plan @task-x-new-cool-feature.md"

Evaluates:

Codebase alignment and current patterns
Scope clarity and completeness
Performance, security, and privacy impact
Code smells and potential caveats

When to use: Before starting complex implementations to validate your approach.

3. `/finalize-plan` - Task Completion Documentation

Purpose: Finalizes completed tasks by creating finished plan files and lightweight summaries.

Usage:

/finalize-plan TASK_FILE="docs/tasks/todo/01-user-auth.md"

Features:

Moves task to finished directory with status
Creates lightweight summary file (SOW - Summary of Work)
Cross-references between plan and summary
Tracks affected files, tests, and decisions
Token-optimized for AI consumption

When to use: When tasks are completed to maintain organized documentation.

4. `/code-review-low` - Fast Code Review

Purpose: Lightweight code review focusing on critical issues only.

Usage:

/code-review-low "my plan @task-x-cool-feature has been implemented check unstaged files"

Focus Areas:

Code smells and security vulnerabilities
Performance bottlenecks
Essential test coverage

Output:

Summary with top 1-3 risks
Decision: approve | request_changes | blocker
Findings grouped by Smell | Security | Performance | Tests
Exact file and line range references

When to use: After implementing features for quick validation.

5. `/code-review-high` - Thorough Code Review

Purpose: Comprehensive code review with extended analysis for major changes.

Usage:

/code-review-high "@auth.server.ts @auth.rs @auth.connector.ts"

Includes: All code-review-low checks plus:

Deeper security and performance analysis
Comprehensive test recommendations
Architecture and design pattern review
Dependency and integration analysis

When to use: For major changes or before releases.

6. `/problem-analyzer` - Bug Identification and Impact Analysis

Purpose: Identifies bugs and maps affected files across the codebase.

Usage:

/problem-analyzer "the app won't compile. here are the logs <paste-logs>"

Provides:

Root cause analysis
File impact assessment
Minimal safe fix proposals
Documentation gap identification

Pro tip: Works best when combined with error logs and a short problem description. Consider using with faster models like Cheetah for quick analysis, then switching to more capable models for detailed solutions.

When to use: During debugging sessions for faster issue resolution.

7. `/refactor-code` - Structured Refactoring Workflows

Purpose: Initiates refactoring workflows with clear scope and isolation.

Usage:

/refactor-code "here is our implementation plan @impl-plan lets start"

Features:

Feature-specific refactoring scope
Commit isolation guidelines
Documentation of unrelated issues (without fixing)
No backward compatibility or feature flags

When to use: When starting refactoring work to maintain clean commit history.

8. `/kill-port` - Port Management Utility

Purpose: Kills processes running on specified ports with OS-specific commands.

Usage:

/kill-port "3000"
/kill-port "3000 8080 9000"  # Multiple ports

Features:

Cross-platform support (macOS, Linux, Windows)
Process identification and verification
Safety warnings for system processes
Graceful shutdown recommendations

When to use: When ports are occupied and need to be freed up.

9. `/research-better-lib` - Library Evaluation Framework

Purpose: Comprehensive template for evaluating alternatives to baseline libraries.

Usage:

/research-better-lib "Fuse.js fuzzy search fuzzysort quick-score FlexSearch MiniSearch"

Features:

Structured problem statement and success metrics
Search query templates for benchmarking
Candidate library shortlist evaluation
Minimal benchmark design guidelines
Decision rubric and deliverables checklist

When to use: When considering library replacements to find modern, faster alternatives.

10. `/ask-codefetch` - Codebase Context Gathering

Purpose: Gathers narrowed codebase context into a single markdown file using codefetch.

Usage:

npx codefetch --max-tokens 50000 \
  --output codefetch/codebase.md \
  --token-encoder o200k \
  --project-tree 3 \
  --include-files "src/auth/**/*.ts,src/api/**/*.ts" \
  --include-dir "src/utils"

Workflow:

Research: identify relevant files/directories for the task
Generate: run codefetch with scoped files → single .md file
Read: use codefetch/codebase.md as context

When to use: When you need to provide context to an AI about specific parts of your codebase.

11. `/ask-codefetch-pro` - Quick Codebase Analysis

Purpose: Generate codebase, copy to clipboard, and automatically open AI chat.

Usage:

# ChatGPT (default)
npx codefetch open --max-tokens 50000 \
  --token-encoder o200k \
  --project-tree 3 \
  --include-files "src/**/*.ts"

# Gemini
npx codefetch open --chat-url gemini.google.com --chat-model gemini-3.0 \
  --max-tokens 50000 --include-files "src/**/*.ts"

# Claude
npx codefetch open --chat-url claude.ai --chat-model claude-3.5-sonnet \
  --max-tokens 50000 --include-files "src/**/*.ts"

When to use: For quick codebase analysis with automatic clipboard and browser integration.

12. `/solidjs-rules` - SolidJS Best Practices

Purpose: Comprehensive SolidJS coding rules and best practices.

Usage:

/solidjs-rules CODEFILES="@Button.tsx @TodoList.tsx"

Covers:

Reactivity basics and signal usage
Control flow helpers (Show, For, Switch)
Async and side effect patterns
Component API and prop guidelines
Styling conventions
File and folder organization
ESLint configuration examples

When to use: When working with SolidJS codebases to ensure best practices.

13. `/component-cleanup` - SolidJS Component Structure

Purpose: SolidJS component size and structure rules for code cleanup.

Usage:

/component-cleanup CODEFILES="@UserProfile.tsx"

Guidelines:

Component size guidelines (150-250 LOC target, 600 LOC hard cap)
File naming conventions
Component splitting strategies
Logic extraction to hooks/utilities
JSX nesting limits

When to use: When reviewing or refactoring SolidJS components.

14. `/short-tokens` - Token Optimization

Purpose: Minimizes token usage while retaining all key information.

Usage:

/short-tokens TEXT="@long-documentation.md"

Principles:

Trim aggressively for token savings
Retain every key fact, figure, and conclusion
Remove redundancy and filler
Avoid ** asterisk formatting
Every token consumes space in agent token windows

When to use: When optimizing text content for AI token windows.

Recommended Workflow Integration

Daily Development Workflow

Morning Planning: Use /create-plan for new tasks
Pre-Implementation: Use /plan-review to validate approach
During Development: Use /problem-analyzer when bugs appear
Post-Implementation: Use /code-review-low for quick validation
Major Milestones: Use /code-review-high before releases
Task Completion: Use /finalize-plan to document outcomes

Team Collaboration

Share commands through project-level .claude/commands/ directories
Standardize reviews using /code-review-low or /code-review-high
Document decisions using /finalize-plan summaries
Debug together using /problem-analyzer with shared logs

SolidJS Projects

Use /solidjs-rules for onboarding new developers
Apply /component-cleanup during code reviews
Combine both for comprehensive SolidJS quality checks

Comparison with Built-in Alternatives

Feature	regenrek slash-commands	Claude Code Built-in `/review`
Code Review Levels	Two: low (fast) and high (thorough)	Single level
Customization	Fully editable Markdown templates	Fixed prompt
Planning Focus	Dedicated `/create-plan`, `/plan-review`	Not included
Problem Analysis	Specialized `/problem-analyzer`	General debugging
Refactoring	Structured `/refactor-code` workflow	Not specialized
Cross-Platform	Claude Code, Cursor, Codex	Claude Code only
Community	Open source, forkable	Proprietary

Tips and Best Practices

Start Simple: Begin with /create-plan and /code-review-low for immediate value
Customize: Edit the Markdown templates to match your team’s conventions
Version Control: Commit your custom commands alongside your code
Combine Workflows: Chain commands together (e.g., /create-plan → /plan-review → /code-review-low)
Document Patterns: Use /finalize-plan to create reusable patterns for future work

About the Author

Kevin Kern (@kregenrek | kevinkern.dev) is the creator of the slash-commands collection and founder of instructa.ai, where he teaches developers how to build software with AI.

Related Projects:

codex-1up - OpenAI Codex Tools
AI Prompts - Curated AI Prompts for Cursor AI, Cline, Windsurf and Github Copilot
codefetch - Turn code into Markdown for LLMs
aidex - CLI tool for AI language model information

Conclusion

The slash-commands collection by regenrek transforms AI coding assistants from generic tools into personalized, team-oriented productivity systems. By providing 14 carefully crafted commands covering planning, review, debugging, refactoring, and optimization, this collection addresses real workflows that developers face daily.

Whether you’re working solo or part of a team, these commands help maintain consistency, catch issues early, and document decisions effectively. The beauty lies in their simplicity—Markdown files that can be customized, shared, and version-controlled alongside your code.

Start with /create-plan and /code-review-low, then gradually incorporate more commands as your team’s needs evolve. Your future self (and your teammates) will thank you for the investment in standardized, efficient workflows.

References

Compound Engineering Plugin: Official Claude Code Plugin That Makes Each Unit of Engineering Work Easier

Jan 3, 2026

Vibe Sparking

Compound Engineering Plugin: Official Claude Code Plugin That Makes Each Unit of Engineering Work Easier

“Each unit of engineering work should make subsequent units easier—not harder.”

In traditional software development, every feature added makes the next feature harder to build. More code means more edge cases, more interdependencies, and more complexity. This accumulation of technical debt is the default trajectory for most codebases.

EveryInc’s compound-engineering-plugin for Claude Code inverts this paradigm. It implements a compound engineering methodology where each unit of work makes future work easier through a systematic learning loop.

Introduction and Key Features

The compound-engineering-plugin is an official Claude Code plugin developed by EveryInc that orchestrates AI agents to plan, write, review, and compound engineering knowledge. The plugin embodies a revolutionary approach to software development where:

80% of effort goes into planning and review - ensuring thorough understanding before code is written
20% goes into execution - leveraging AI agents for code generation
Knowledge compounds over time - each lesson learned feeds back into the system

Key Highlights

Feature	Description
Four-Step Workflow	Plan → Work → Review → Compound → Repeat
Multi-Agent Orchestration	Parallel agents handle research, implementation, and review
Knowledge Compounding	Learnings are systematically captured and reused
Worktree Management	Isolated development environments for each feature
Open Source	MIT licensed, fully auditable and customizable

Prerequisites, Installation and Configuration

Prerequisites

Claude Code installed and configured
Git for worktree management
GitHub CLI (gh) for repository operations

Installation

The installation process is straightforward:

# Add the plugin marketplace
/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin

# Install the compound-engineering plugin
/plugin install compound-engineering

Initial Configuration

Once installed, the plugin provides four main workflow commands:

Command	Purpose
`/workflows:plan`	Turn feature ideas into detailed implementation plans
`/workflows:work`	Execute plans with worktrees and task tracking
`/workflows:review`	Multi-agent code review before merging
`/workflows:compound`	Document learnings to make future work easier

Recommended Scenarios and Best Practices

When to Use Compound Engineering

This methodology excels in these scenarios:

Solo Developers Building Products - One developer can achieve what traditionally required a team of five
Complex Feature Development - Multi-component features that require careful planning
Knowledge-Intensive Codebases - Projects where context and patterns matter significantly
Long-Term Projects - Projects where compound effects have time to accumulate

Daily Workflow Example

Here’s how a typical compound engineering session flows:

Step 1: Plan (80% of the value)

/workflows:plan

The agent:

Researches the codebase and commit history
Scours the internet for best practices
Synthesizes a detailed implementation plan
Identifies potential pitfalls and edge cases

Step 2: Work (20% of the value)

/workflows:work

The agent:

Creates an isolated worktree
Implements according to the plan
Writes tests alongside code
Tracks task completion

Step 3: Review (Critical checkpoint)

/workflows:review

Multiple agents:

Review the code independently
Catch issues and suggest improvements
Evaluate against established patterns
Verify all acceptance criteria

Step 4: Compound (The magic happens)

/workflows:compound

The agent:

Documents lessons learned
Captures new patterns discovered
Updates project knowledge base
Feeds insights back into the system

Best Practices

Never skip the Plan phase - This is where most value is created
Always Review before merging - Multiple perspectives catch more issues
Document everything - Future agents depend on this knowledge
Trust the process - The compound effect takes time to manifest

Precautions, FAQ, and Troubleshooting

Important Considerations

⚠️ Learning Curve

The compound engineering approach requires a mindset shift. Traditional developers accustomed to “just coding” may find the emphasis on planning unfamiliar.

⚠️ Initial Investment

The first few cycles will feel slower than traditional development. This is normal - you’re building the knowledge foundation that future cycles will leverage.

⚠️ Tool Requirements

Full benefits require Claude Code with the plugin installed. The methodology is tool-agnostic in theory but optimized for this stack.

FAQ

Q: Is this only for solo developers?

A: No. While Every uses it to enable solo developers to build complex products, teams can benefit even more from the systematic knowledge capture and multi-agent review process.

Q: Does this work with existing codebases?

A: Yes. The Plan phase includes researching your existing codebase, making it effective for both greenfield and brownfield projects.

Q: Can I use this with other AI coding tools?

A: The plugin is designed for Claude Code, but the compound engineering philosophy is tool-agnostic. Some Every team members also use OpenAI’s Codex CLI.

Q: What happens if the plan is wrong?

A: The Review and Compound phases capture why the plan didn’t work, feeding that learning back into future planning cycles.

Troubleshooting

Issue	Solution
Plugin not found	Ensure marketplace is added before installing
Worktree conflicts	Clean up existing worktrees with `git worktree prune`
Agent hallucinations	Use Review phase with multiple agents to catch issues
Slow performance	Consider reducing research scope in Plan phase

Collaboration with Similar Products and Comparative Analysis

Comparative Landscape

Tool/Approach	Planning	Execution	Review	Knowledge Compounding
Compound Engineering Plugin	✅ Deep research phase	✅ AI-driven	✅ Multi-agent	✅ Core feature
Traditional Development	❌ Ad-hoc	✅ Manual	✅ Optional	❌ Rare
GitHub Copilot	❌ None	✅ AI-assisted	❌ None	❌ None
Cursor AI	⚠️ Limited	✅ AI-driven	⚠️ Limited	❌ None
Droid (Startup Factory)	⚠️ Basic	✅ AI-driven	⚠️ Basic	⚠️ Limited

Key Differentiators

Knowledge Compounding as First-Class Citizen - Most tools focus on code generation; compound engineering focuses on making future work easier
Multi-Agent Review - Leverages multiple AI perspectives to catch issues that single-agent approaches miss
Systematic Learning Loop - Every lesson is captured and fed back into the system
80/20 Planning-to-Execution Ratio - Inverts the traditional emphasis on coding speed

Integration Possibilities

The compound engineering plugin can integrate with:

CI/CD pipelines - Use Review phase as a gate before deployment
Documentation tools - Automatically feed Compound outputs into knowledge bases
Project management - Track worktrees as tasks/features
Code quality tools - Combine with linters, formatters, and security scanners

Real-World Impact

EveryInc runs five software products in-house, each primarily built and run by a single person using compound engineering:

“Today, if your AI is used right, a single developer can do the work of five developers a few years ago, based on our experience at Every.”

— Dan Shipper & Kieran Klaassen, Compound Engineering: How Every Codes With Agents

These aren’t demos - they’re products used by thousands of people daily for important work.

Reference Links

Official Resources

GitHub Repository: EveryInc/compound-engineering-plugin
Plugin Documentation: Full component reference
MIT License: View License

Deep Dives

Compound Engineering: How Every Codes With Agents - Detailed explanation by Dan Shipper and Kieran Klaassen
The Story Behind Compound Engineering - Origin story and philosophy

Community

Every.to: Chain of Thought Newsletter - Ongoing insights on AI and engineering
Claude Plugins.dev: Community Registry - Discover more Claude Code plugins

Summary: The compound-engineering-plugin represents a paradigm shift in software development. By treating knowledge as a first-class artifact and systematically capturing learnings, it makes each unit of engineering work easier than the last. Whether you’re a solo developer or part of a team, this approach offers a path to sustainable, compounding productivity gains.

Ralph Wiggum: The Official Claude Code Plugin for Autonomous AI Development Loops

Jan 3, 2026

Vibe Sparking

Ralph Wiggum: The Official Claude Code Plugin for Autonomous AI Development Loops

Ralph Wiggum Plugin

Introduction: Ralph is Just a Bash Loop

In the world of AI-assisted development, a fascinating technique has emerged from the mind of Geoffrey Huntley. Named after the famously persistent Ralph Wiggum from The Simpsons, the Ralph Wiggum technique embodies a simple yet powerful philosophy: keep trying until you succeed.

As Huntley famously describes it:

“Ralph is a Bash loop” - a simple while true that repeatedly feeds an AI agent a prompt file, allowing it to iteratively improve its work until completion.

Now, Anthropic has released an official Claude Code plugin that implements this technique, bringing autonomous AI development loops to your fingertips.

Understanding the Ralph Wiggum Technique

Core Concept

The Ralph Wiggum technique is built on the principle of persistent iteration despite setbacks. Instead of trying to get everything right in a single shot, you let the AI fail, learn from its failures, and try again - automatically.

The traditional approach to AI-assisted development looks like this:

Human → Ask AI → AI responds → Human reviews → Human asks again → ...

The Ralph Wiggum approach flips this:

Human → Define task with completion criteria
AI → Work → Try to exit → Block exit → See previous work → Try again
... Loop until completion criteria met

How It Works Under the Hood

The official ralph-wiggum plugin implements this using a Stop hook that intercepts Claude’s exit attempts:

# You run ONCE:
/ralph-loop "Your task description" --completion-promise "DONE"

# Then Claude Code automatically:
# 1. Works on the task
# 2. Tries to exit
# 3. Stop hook blocks exit
# 4. Stop hook feeds the SAME prompt back
# 5. Repeat until completion

The loop happens inside your current session - no external bash loops needed. The Stop hook in hooks/stop-hook.sh creates the self-referential feedback loop.

Key Features of the Official Plugin

1. Self-Referential Feedback Loop

The prompt never changes between iterations
Claude’s previous work persists in files
Each iteration sees modified files and git history
Claude autonomously improves by reading its own past work

2. Simple Command Interface

The plugin provides two main commands:

Starting a loop:

/ralph-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. Output <promise>COMPLETE</promise> when done." --completion-promise "COMPLETE" --max-iterations 50

Canceling a loop:

/cancel-ralph

3. Safety Controls

--max-iterations <n> - Prevents infinite loops by stopping after N iterations
--completion-promise "<text>" - Defines the exact phrase that signals completion

Best Practices for Writing Ralph Prompts

The success of the Ralph Wiggum technique depends heavily on how you write your prompts.

❌ Bad Examples

# Too vague - no clear success criteria
"Build a todo API and make it good."

# Too broad - impossible to complete in one go
"Create a complete e-commerce platform."

# No testing/validation specified
"Write code for feature X."

✅ Good Examples

# Clear requirements with completion criteria
Build a REST API for todos.

When complete:
- All CRUD endpoints working
- Input validation in place
- Tests passing (coverage > 80%)
- README with API docs
- Output: <promise>COMPLETE</promise>

# Phased approach for complex tasks
Phase 1: User authentication (JWT, tests)
Phase 2: Product catalog (list/search, tests)
Phase 3: Shopping cart (add/remove, tests)

Output <promise>COMPLETE</promise> when all phases done.

# TDD approach for quality
Implement feature X following TDD:
1. Write failing tests
2. Implement feature
3. Run tests
4. If any fail, debug and fix
5. Refactor if needed
6. Repeat until all green
7. Output: <promise>COMPLETE</promise>

When to Use Ralph Wiggum

✅ Good For

Well-defined tasks with clear success criteria
Tasks requiring iteration (e.g., getting tests to pass)
Greenfield projects where you can walk away
Tasks with automatic verification (tests, linters)

❌ Not Good For

Tasks requiring human judgment or design decisions
One-shot operations
Tasks with unclear success criteria
Production debugging (use targeted debugging instead)

Real-World Results

The Ralph Wiggum technique has demonstrated impressive real-world outcomes:

Successfully generated 6 repositories overnight in Y Combinator hackathon testing
One $50k contract completed for $297 in API costs
Created an entire programming language (“cursed”) over 3 months using this approach

Philosophy Behind the Technique

Ralph embodies several key principles that make it effective:

Don’t aim for perfect on first try - Let the loop refine the work
“Deterministically bad” means failures are predictable - Use them to tune prompts
Success depends on writing good prompts - Not just having a good model
Keep trying until success - The loop handles retry logic automatically

Installation and Setup

The Ralph Wiggum plugin is available in the official Anthropic Claude plugins repository:

# Clone the official plugins repo
git clone https://github.com/anthropics/claude-plugins-official.git

# The plugin is located at:
# plugins/ralph-wiggum/

Key files in the plugin:

.claude-plugin - Plugin configuration
commands/ - Command definitions (/ralph-loop, /cancel-ralph)
hooks/stop-hook.sh - The magic that makes the loop work
scripts/ - Supporting scripts

Advanced Usage: Ralph Orchestrator

For more complex workflows, the Ralph Orchestrator provides enhanced functionality:

Web-based interface for managing multiple Ralph loops
Parallel execution of multiple tasks
Progress monitoring and logging
Integration with CI/CD pipelines

Learn more about Ralph Orchestrator

Conclusion

The Ralph Wiggum plugin represents a paradigm shift in how we think about AI-assisted development. Instead of treating AI as a one-shot tool, it embraces the reality that software development is iterative - and AI should be too.

By letting Claude fail, learn, and try again automatically, we unlock a level of autonomy that wasn’t possible before. Whether you’re building a REST API, generating test suites, or working on a complex multi-phase project, Ralph Wiggum gives you the power to define the destination and let AI find the path.

References

Published: January 3, 2026 Author: VibeSparking AI Research Team

pg-aiguide: AI-Optimized PostgreSQL Expertise for Coding Assistants

Dec 31, 2025

Vibe Sparking

pg-aiguide: AI-Optimized PostgreSQL Expertise for Coding Assistants

In the rapidly evolving landscape of AI-powered development tools, one challenge has persisted: AI coding assistants often generate database code that is outdated, missing critical constraints, unaware of modern PostgreSQL features, and inconsistent with real-world best practices.

Enter pg-aiguide – an innovative MCP server and Claude plugin developed by Timescale (now Tiger Data) that provides AI-optimized PostgreSQL expertise to coding assistants.

What is pg-aiguide?

pg-aiguide is an open-source tool (Apache-2.0 licensed) that helps AI coding tools write dramatically better PostgreSQL code. It provides three core capabilities:

Semantic Search across the official PostgreSQL manual (version-aware)
AI-Optimized Skills – curated, opinionated Postgres best practices used automatically by AI agents
Extension Ecosystem Docs, starting with TimescaleDB, with more extensions coming soon

The Problem pg-aiguide Solves

AI coding tools frequently generate PostgreSQL code that suffers from several issues:

Outdated syntax – not keeping up with modern PostgreSQL versions
Missing constraints and indexes – leading to poor data integrity and performance
Unaware of modern PG features – missing out on capabilities introduced in recent versions
Inconsistent with best practices – not following proven patterns from experienced developers

Real-World Impact

The pg-aiguide team conducted an impressive comparison test. When asked to create an e-commerce database schema:

4× more constraints compared to AI without pg-aiguide
55% more indexes (including partial and expression indexes)
PG17-recommended patterns – using the latest PostgreSQL features
Modern features like GENERATED ALWAYS AS IDENTITY and NULLS NOT DISTINCT
Cleaner naming & documentation – more maintainable code

Installation & Setup

pg-aiguide can be used in two ways:

As a Public MCP Server

Available at https://mcp.tigerdata.com/docs, it can be configured for any AI coding agent:

{
  "mcpServers": {
    "pg-aiguide": {
      "url": "https://mcp.tigerdata.com/docs"
    }
  }
}

As a Claude Code Plugin

For Claude Code users, installation is straightforward:

claude plugin marketplace add timescale/pg-aiguide
claude plugin install pg@aiguide

Supported AI Tools

pg-aiguide supports a wide range of AI coding environments:

Claude Code – Native plugin support
Cursor – One-click install available
Gemini CLI – MCP server integration
VS Code / VS Code Insiders – Command-line installation
Windsurf – Configuration-based setup
Codex – MCP server integration

Key Features

Semantic Documentation Search

The semantic_search_postgres_docs function performs semantic search over the official PostgreSQL manual, with results scoped to specific Postgres versions. This means AI agents get accurate, version-relevant information.

Extension Ecosystem Support

Through semantic_search_tiger_docs, pg-aiguide searches Tiger Data’s documentation corpus, including TimescaleDB and future ecosystem extensions.

Curated Best Practices

The view_skill function exposes opinionated PostgreSQL best-practice skills covering:

Schema design patterns
Indexing strategies
Data type selection
Data integrity and constraints
Naming conventions
Performance tuning
Modern PostgreSQL features

Use Cases

Simple Schema Design

Prompt: “Create a Postgres table schema for storing usernames and unique email addresses.”

pg-aiguide helps generate properly constrained schemas with appropriate indexes and modern PostgreSQL types.

Complex IoT Schema

For more complex scenarios, like an IoT device monitoring system:

“Generate a Postgres schema for an IoT device company. Devices collect environmental data including temperature, humidity, pressure, and other measurements. Each device has a unique ID and human-readable name. Analysis includes finding outliers, anomalies, and device-specific ad-hoc analysis.”

pg-aiguide helps design schemas optimized for both recent data analysis and historical reporting.

Technology Stack

Python (66.5%) – Core server logic
TypeScript (23.1%) – Plugin integrations
JavaScript (9.3%) – Web interfaces

Future Plans

The project has an ambitious roadmap:

pgvector support for vector similarity search
PostGIS for geospatial data
Community contributions for additional extensions

Contributing

pg-aiguide welcomes contributions in several areas:

New Postgres best-practice skills
Additional documentation corpora
Search quality improvements
Bug reports and feature ideas

Conclusion

pg-aiguide represents a significant step forward in AI-assisted database development. By providing AI agents with deep, versioned PostgreSQL knowledge and proven patterns, it bridges the gap between AI-generated code and production-quality database schemas.

Whether you’re a developer using AI coding assistants or a team building AI-powered development tools, pg-aiguide offers a practical solution to the persistent problem of suboptimal AI-generated database code.

Links

GitHub: timescale/pg-aiguide
MCP Server: https://mcp.tigerdata.com/docs
License: Apache-2.0
Author: Timescale (Tiger Data)

Published: December 31, 2025

Practical Review: Building HeartPetBond App with Claude Code + BMAD + GLM-4.7

Dec 31, 2025

Vibe Sparking

Core Insight: Can Zhipu GLM-4.7 replace the expensive Opus 4.5 in the Claude Code environment? How does its 200K context window perform within the document-driven BMAD workflow? This post reveals the answers through the real-world development of the HeartPetBond app.

1. Motivation: Why This Review?

In the AI-assisted programming realm, Claude Opus 4.5 has been the undisputed king, but its high cost (approx. $15/1M input, $75/1M output) deters high-frequency usage. DeepSeek V3, while affordable, occasionally hits bottlenecks with ultra-long contexts (>128K tokens).

I aimed to verify Zhipu GLM-4.7, a strong challenger to DeepSeek V3, by developing the HeartPetBond app to test:

Long Context Capability: Can the nominal 200K Tokens Context support an entire project’s documentation and codebase?
Output Length: Can the 128K Tokens Output generate complex Flutter pages in one go?
Stability & Hallucination: Does logic crumble during continuous development over several days?
Cost-Effectiveness: How much money can it save independent developers compared to Opus 4.5?

Context: When using DeepSeek V3 with Claude Code + BMAD, I encountered errors like API Error: 400 ... maximum context length is 131072 tokens... when the context exceeded 128K. GLM-4.7’s 200K context might be the solution.

With over 10 years of Flutter experience and previous success generating the MoneyMind App using Claude Code + BMAD, I set out to see if this new model could handle the challenge.

2. Setup: Integrating GLM-4.7 into Claude Code

Switching Claude Code’s “brain” is straightforward:

1. Install BMAD

First, we introduce the BMAD (Building Multi-Agent Development) system, the core methodology that makes AI “understand engineering standards.”

bunx bmad-method@alpha install

2. Configure ZHIPU GLM-4.7

Claude Code supports connecting external models via MCP or API adapters.

Register and subscribe to the Zhipu BIGMODEL platform to get an API Key.
Configure the default model in Claude Code (or related MCP settings) to point to GLM-4.7.

3. From Idea to Product: The Automated Workflow

Following the BMAD workflow, HeartPetBond’s birth followed standard Document Driven Development. Here are the key milestones:

1. Initialize Workflow

> /bmad:bmm:workflows:workflow-init

BMAD scanned the project state and provided a precise analysis:

🎉 Welcome to BMad Method, Vibe Sparking!

📊 Project State Analysis
Status: ACTIVE - You already have workflow tracking!
...
Current Configuration:
Project: vs-heart-pet-bond (Mobile App)
Type: Greenfield (new project)

2. Create Product Brief

After confirming brainstorming results, the AI generated the product definition:

> /bmad:bmm:workflows:create-product-brief

Key Findings from Brainstorming Session:
- Product: HeartPetBond - Shared Pet Care Log & Reminders App
- Tech Stack: Flutter + GetX + Drift
- Core Philosophy: 1-second recording, frictionless tracking

It even locked in the tech stack: Flutter for cross-platform UI, GetX for lightweight state management, and Drift for local persistence.

4. PoC Verification & Performance

After switching to GLM-4.7, I was most surprised by its “throughput speed” and “depth of understanding.”

1. Development Speed

In just 2-3 days, GLM-4.7 helped me complete 5 core pages for HeartPetBond (PoC phase):

Welcome Page: User onboarding.
Ready State: State checks.
Home Page: Core recording flow.
Settings: Complex configuration management.

The code pass rate was extremely high, rarely missing brackets or breaking logic even in deep Flutter Widget trees.

2. Token Usage

The cost breakdown is impressive:

PoC Phase Total: Approx. 300 Million (300M) tokens.
Estimated MVP: For 15 pages and App Store submission, estimated 3 Billion (3B) tokens.

Despite this massive volume, GLM-4.7’s cost is only about 1/7th of Opus 4.5. A Pro subscription (~¥200/month) essentially covers the MVP development needs.

5. Wrap Up

The verdict from this field test is clear: Building mobile apps with GLM-4.7 + Claude Code + BMAD is entirely feasible and highly cost-effective.

✅ Pros

High Cost-Performance: GLM-4.7 is a perfect “affordable alternative” to Opus 4.5. It significantly outperforms DeepSeek V3 in daily coding tasks while remaining wallet-friendly.
Long Window Stability: The 200K Context Window is real. It maintained clarity without “catastrophic forgetting” even after loading mass amounts of BMAD documentation.
Engineering Ready: Works seamlessly with Claude Code’s toolchain to handle complex refactoring and debugging.

⚠️ Cons

Reasoning Minor Flaws: In very complex business flow designs, GLM-4.7’s reasoning chain occasionally misses a step compared to the meticulous Opus 4.5. This is manageable via human Code Review and clearer prompts.
Multimodal Gaps: Current API support for multimodal inputs (images/files) is limited, requiring an additional zai-mcp-server configuration.

🔮 Final Verdict

If you are an independent developer looking for a smart AI pair programmer that won’t break the bank, Claude Code + GLM-4.7 + BMAD is the combination to beat right now.

Life is compounding. Start building your bond today.

ClaudeCode Workflow Studio: Visual Automation Editor for AI Workflows

Dec 29, 2025

Vibe Sparking

ClaudeCode Workflow Studio: Visual Automation Editor for AI Workflows

Claude Code, Anthropic’s official CLI tool for AI-assisted development, has a powerful automation system through its .claude configuration files. However, creating complex workflows with multiple sub-agents, conditional branching, and user interactions requires editing markdown and YAML files manually. ClaudeCode Workflow Studio (cc-wf-studio) by breaking-brake brings a visual, drag-and-drop editor to VSCode, making workflow creation intuitive and accessible.

ClaudeCode Workflow Studio

What is ClaudeCode Workflow Studio?

ClaudeCode Workflow Studio is a VSCode extension that provides a visual workflow editor for Claude Code. It allows you to:

Design workflows visually - Drag and drop nodes onto a canvas
Configure without code - Set up sub-agents, skills, and MCP tools through a UI
Export with one click - Generate .claude/agents/ and .claude/commands/ files automatically
Collaborate with your team - Share workflows via Slack with preview cards

GitHub Repository: breaking-brake/cc-wf-studio VSCode Marketplace: Open VSX License: AGPL-3.0-or-later Version: 3.9.1 (as of December 2025)

Key Features

1. Visual Workflow Editor

The core of cc-wf-studio is its drag-and-drop canvas. Instead of writing markdown and YAML, you visually connect nodes to define workflow logic:

Prompt Nodes - Define reusable prompt templates with {{variable}} substitution
Sub-Agent Nodes - Configure autonomous AI agents with custom system prompts and tool permissions
Skill Nodes - Integrate Claude Code Skills from personal or project directories
MCP Nodes - Connect to Model Context Protocol tools for external integrations
Control Flow Nodes - IfElse (binary branching), Switch (multi-way branching), AskUserQuestion (user decisions)

One of the standout features is AI-assisted refinement. Instead of generating workflows from scratch once, you can iteratively improve them through conversation:

Click the “Edit with AI” button (✨ sparkle icon)
Describe your changes in natural language (max 2000 characters)
The AI modifies your workflow incrementally, preserving existing work
Repeat until satisfied

This conversational approach builds workflows through multiple rounds of feedback, with the AI maintaining conversation history and applying changes incrementally.

Example prompts:

“Add a Sub-Agent node that validates the input data”
“Connect the error handler to a logging Sub-Agent”
“Change the AskUserQuestion node to have 3 options: High, Medium, Low”

3. One-Click Export

When your workflow is ready, click Export to generate:

.claude/agents/*.md - Sub-Agent definitions with system prompts and tool configurations
.claude/commands/*.md - SlashCommand definitions that execute the entire workflow

The exported files are ready to use immediately with Claude Code CLI. No manual editing required.

For teams, cc-wf-studio offers Slack integration:

Export workflows to Slack channels with preview cards
One-click import links for team members
Seamless collaboration without leaving your chat workspace

Installation

From VSCode Marketplace (Recommended)

Open VSCode Extensions (Ctrl+Shift+X / Cmd+Shift+X)
Search for “Claude Code Workflow Studio”
Click Install

From Open VSX

The extension is also available on Open VSX:

Install the Open VSX extension
Search for “cc-wf-studio”
Click Install

From Source

Clone the repository:

git clone https://github.com/breaking-brake/cc-wf-studio.git
cd cc-wf-studio

Install dependencies:

npm install
cd src/webview && npm install && cd ../..

Build the extension:
Terminal window
```
npm run build
```
Package and install:
Terminal window
```
npx vsce package
```
Install the generated .vsix file through VSCode’s “Install from VSIX…” option

Quick Start Guide

1. Open the Editor

Press Ctrl+Shift+P / Cmd+Shift+P
Type “Claude Code Workflow Studio: Open Editor”
Press Enter

First-time users get an interactive onboarding tour (available in English, Japanese, Korean, Simplified Chinese, and Traditional Chinese).

2. Create Your Workflow

The left palette is organized into sections:

Basic Nodes: Prompt (templates), Sub-Agent (AI tasks)
Control Flow: IfElse (binary branching), Switch (multi-way branching), AskUserQuestion (user decisions)
Integration: Skill (Claude Code Skills), MCP (external tools)

Steps:

Drag nodes from the palette onto the canvas
Click a node to edit its properties in the right panel
Connect nodes by dragging from output ports (right) to input ports (left)
Configure node-specific settings (prompts, variables, conditions)

3. Save & Export

Enter a workflow name in the toolbar
Click Save to store as JSON in .vscode/workflows/
Click Export to generate .claude files

Node Types Deep Dive

Prompt Nodes

Define reusable prompt templates with template variables:

Hello {{userName}}, your task today is to {{taskType}}.

Variables are automatically detected and validated. At runtime, values are dynamically substituted.

Sub-Agent Nodes

Configure autonomous AI agents with:

System Prompt - Custom instructions for the agent
Tool Permissions - Choose which tools the agent can access (Read, Write, Bash, etc.)
Model Selection - Sonnet (balanced), Opus (complex tasks), Haiku (speed)

Skill Nodes

Integrate Claude Code Skills into your workflows:

Personal Skills - From ~/.claude/skills/ for individual use
Project Skills - From .claude/skills/ for team collaboration
Create New Skills - Build skills directly from the visual editor with a guided form
Browse & Select - Interactive skill browser with descriptions

MCP Nodes

Integrate Model Context Protocol tools:

Select an MCP server from the dropdown (configured in Claude Code)
Browse available tools or use search to filter
Configure parameters with dynamic form generation based on tool schemas
Real-time validation with error messages

Prerequisites: MCP servers must be configured in Claude Code settings first.

Control Flow Nodes

IfElse Node

Fixed 2-way branching for binary conditions (True/False, Yes/No, Success/Error).

Switch Node

Variable multi-way branching (2-N branches) with dynamic case management. Ideal for complex routing logic.

Usage Examples

Example 1: Document Analysis Workflow

Upload Document Prompt - Asks user for file path
PDF Extractor Skill (Personal) - Extracts text from PDF files
Ask User - “Processing type?” → Summarize / Translate / Analyze
Document Processor Skill (Project) - Team-shared processing logic
Format Results Sub-Agent - Creates final output

Example 2: Code Quality Scanner

Code Scanner Sub-Agent - Identifies issues
Ask User - “Priority level?” → Critical Only / All Issues
Filter Results Sub-Agent
Generate Fix Suggestions Sub-Agent

Example 3: Web Automation with Playwright

Input URL Prompt - Asks user for target website
Playwright Navigate MCP Tool - Opens browser and navigates to URL
Ask User - “Action type?” → Screenshot / Extract Text / Click Element
Playwright Action MCP Tool - Performs the selected browser action
Process Results Sub-Agent - Analyzes and formats output

Internationalization

The Visual Editor UI and all exported files automatically adapt to your VSCode display language setting (vscode.env.language). Supported languages:

English (default)
Japanese
Korean
Simplified Chinese (zh-CN)
Traditional Chinese (zh-TW/zh-HK)

This ensures both the editing experience and generated workflows are accessible for international teams.

Limitations

Maximum 50 nodes per workflow
AI processing timeout (default 90 seconds, configurable: 30s-5min)
Request limited to 2000 characters for AI refinement
Conversation history stored only during active session
Requires active Claude Code CLI installation

Troubleshooting

Workflow won’t save

Ensure workflow name contains only letters, numbers, hyphens, and underscores
Check all required fields are filled
Look for error messages in VSCode notifications

Export fails

Verify all nodes have valid configurations
Ensure node names are unique
Check write permissions for .claude directory

Can’t load workflow

Click refresh button (↻) to update the list
Verify file exists in .vscode/workflows/
Check JSON file isn’t corrupted

License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-or-later).

Key points:

You can use, modify, and distribute the software
If you modify and deploy (including as a network service), you must make source code available under AGPL-3.0
Commercial use is allowed, but proprietary modifications are not

Acknowledgments

Built with React Flow • Powered by Claude Code • Inspired by Dify

Why This Matters

ClaudeCode Workflow Studio bridges the gap between technical power and accessibility. By bringing visual programming to Claude Code workflows, it:

Lowers the barrier to entry - No need to understand markdown/YAML structure
Accelerates development - Visual feedback reduces trial-and-error
Enables collaboration - Teams can share and review workflows visually
Integrates seamlessly - Exports work directly with Claude Code CLI

As the Claude Code ecosystem continues to evolve, tools like cc-wf-studio demonstrate how community extensions can enhance the core platform’s capabilities.

Links

Ghostty Founder's Vibe Coding: A Conversational Journey with Claude

Dec 29, 2025

Vibe Sparking

Ghostty Founder’s Vibe Coding: A Conversational Journey with Claude

When Mitchell Hashimoto, founder of Ghostty (the modern, GPU-accelerated terminal emulator), wanted to improve the macOS update feature, he didn’t just write code — he had a conversation. In a remarkable session he calls “vibe coding,” Mitchell paired with Claude to iteratively improve the codebase through dialogue, exploration, and shared discovery.

This isn’t about AI replacing developers. It’s about AI as a collaborative partner — and the transcript shows something beautiful: the AI catches things humans miss, the human provides direction and context, and together they build something better than either could alone.

Ghostty Terminal

What is “Vibe Coding”?

Vibe coding is a conversational approach to software development where the developer and AI work together through natural dialogue. Rather than treating the AI as a command-execution tool, the developer treats it as a pair programmer — discussing, exploring, and iterating together.

In Mitchell’s session, captured from a real coding conversation on AmpCode, the flow goes like this:

Oracle Consultation — Ask Claude to analyze code for improvements
Discussion — Talk through the findings, make decisions together
Implementation — Write code with Claude’s assistance
Iteration — Learn from failures, adjust approach, try again
Testing — Verify changes work, add tests for confidence

The Session: Improving Ghostty’s Update Feature

Mitchell started with a simple request: “Are there any other improvements you can see to be made with the @macos/Sources/Features/ Update feature? Don’t write any code. Consult the oracle.”

The “oracle” — Claude in analysis mode — identified several categories of improvements:

Critical Safety Issues

Retain cycle in UpdateDriver.showUpdaterError — The retry closure captured self strongly, creating a memory leak
Threading issues — UI-facing types should be marked @MainActor
Progress value bugs — Progress values needed clamping to [0, 1] to prevent visual glitches
Uncancellable timer — The “No Updates” auto-dismiss task could fire stale updates
Swallowed errors — try? hid potential failures in startUpdater()

Areas Needing Unit Tests

ReleaseNotes parsing — Semver detection, git hash handling, edge cases
UpdateState Equatable — Equality tests for downloading/error states
ViewModel formatting — Text/icon/color mappings for each state
Progress math — Division by zero, nil values, overshoot scenarios
Auto-dismiss timing — Verify transitions and task cancellation

UX Improvements

Add accessibility labels for assistive technologies
Clamp/abbreviate long error messages to prevent UI overflow

The Conversational Dance

What makes this session remarkable is the back-and-forth:

Mitchell: “Stop stop stop. Undo all the main actor stuff.”

Claude: “Done! I’ve reverted all the @MainActor changes. The build now succeeds…”

Mitchell: “For the error message, instead of truncating, isn’t there a SwiftUI standard way to do this?”

Claude: “You’re absolutely right! SwiftUI has .lineLimit() and .truncationMode() for this…”

The human provides course correction when the AI goes down a problematic path. The AI suggests better approaches when the human asks questions. They learn from each other.

Key Improvements Made

1. Fixed Retain Cycle

retry: { [weak self, weak viewModel] in
    viewModel?.state = .idle
    DispatchQueue.main.async { [weak self] in
        guard let self else { return }
        // ... rest of code
    }
}

2. Clamped Progress Values

let progress = min(1, max(0, Double(download.progress) / Double(expectedLength)))
ProgressView(value: progress)

3. Made Auto-Dismiss Task Cancellable

@State private var resetTask: Task<Void, Never>?

onChange(of: model.state) { newState in
    resetTask?.cancel()  // Cancel any existing task
    if case .notFound = newState {
        resetTask = Task { [weak model] in
            try? await Task.sleep(for: .seconds(5))
            guard !Task.isCancelled, case .notFound? = model?.state else { return }
            model?.state = .idle
        }
    }
}

4. Added Accessibility Labels

.accessibilityLabel(model.text)

Simple, but critical — assistive technologies can now announce update status to visually impaired users.

5. Comprehensive Unit Tests

The session added three new test files:

UpdateStateTests.swift — 150+ lines testing Equatable conformance for all states
UpdateViewModelTests.swift — 300+ lines testing formatting (text, icons, colors)
ProgressTests.swift — 150+ lines testing progress math edge cases

What This Session Teaches Us

1. AI Sees Things Humans Miss

The oracle caught a retain cycle and progress value bugs that weren’t obvious. Code review tools often miss these too — having an AI analyze the code with fresh eyes catches different classes of issues.

2. Humans Provide Critical Judgment

When the AI suggested marking everything @MainActor, Mitchell recognized this would cause cascading compilation issues and asked to revert. Human judgment about architecture and trade-offs remains essential.

3. Iteration is Learning

The session goes through multiple attempts:

First attempt at @MainActor fails → revert and try different approach
Manual error truncation → “isn’t there a SwiftUI standard way?” → use .truncationMode()

Each failure teaches something. The conversation enables rapid iteration.

4. Tests Provide Confidence

The oracle suggested comprehensive unit tests. Writing tests alongside fixes ensures the improvements work correctly and prevents regressions.

5. Accessibility Shouldn’t Be an Afterthought

The UX improvements weren’t flashy features — they were accessibility labels and proper text truncation. These make the software usable for everyone.

The Vibe Coding Workflow

Based on Mitchell’s session, here’s a pattern for vibe coding:

Ask, Don’t Command — “What improvements do you see?” vs “Fix this bug”
Discuss Before Implementing — Talk through the findings, understand the why
Implement Incrementally — Make one change at a time, verify it works
Course Correct — Don’t be afraid to say “stop, undo that”
Add Tests — Build confidence through test coverage
Celebrate Learning — Each failure is a learning opportunity

Tools Used

Claude Code — AI pair programmer for the conversation
Swift/SwiftUI — Ghostty’s macOS frontend
Sparkle — macOS update framework
Swift Testing — Modern testing framework

Links

Original Thread: AmpCode - Potential improvements for macos update feature
Ghostty: ghostty.org
Mitchell Hashimoto: @mitchellh on AmpCode

Conclusion

Vibe coding isn’t about AI writing code for you. It’s about having a conversation with code — where the AI brings analytical superpowers, the human brings judgment and context, and together they create something better.

Mitchell’s session shows the future of programming: not humans replaced by AI, but humans augmented by AI — working together, learning from each other, and building better software through conversation.

The improvements to Ghostty’s update feature — safer code, better tests, improved accessibility — are a testament to what’s possible when developers embrace AI as a collaborative partner rather than a mere tool.

Lovcode: Desktop Companion for Claude Code with Chat History & Configuration Management

Dec 29, 2025

Vibe Sparking

Lovcode: Desktop Companion for Claude Code

Claude Code has revolutionized AI-assisted development, but managing its extensive configuration files, chat history, and custom skills across multiple projects can be challenging. Enter Lovcode — a beautiful desktop companion application that brings all your Claude Code management needs into one unified interface.

Lovcode Desktop Companion

What is Lovcode?

Lovcode is a cross-platform desktop application built as a companion for AI coding tools, with primary focus on Claude Code. It provides a graphical interface to browse chat history, manage configurations, commands, skills, hooks, and more — all without touching the command line.

GitHub Repository: MarkShawn2020/lovcode Author: Mark Shawn (@markshawn2020) License: Apache-2.0 Platforms: macOS • Windows • Linux Latest Version: v0.19.0

Key Features

Chat History Viewer

Browse and search through all your Claude Code conversations across projects with full-text search capabilities. Quickly find past solutions, code snippets, or discussions without digging through JSON files.

Commands Manager

View and manage all your slash commands from ~/.claude/commands/. Edit, create, and organize commands through a clean interface.

MCP Servers Configuration

Configure and monitor Model Context Protocol (MCP) server integrations visually. Manage connections, settings, and status without editing configuration files.

Skills Management

Manage your reusable skill templates — install, configure, and organize skills from one place.

Hooks Automation

Configure automation triggers that execute at specific events during your Claude Code sessions.

Sub-Agents Control

Manage AI agents with custom models and configurations directly from the UI.

Output Styles

Customize response formatting and display preferences.

Marketplace

Browse and install community-contributed templates and configurations.

Tech Stack

Layer	Technology
Frontend	React 19, TypeScript, Tailwind CSS, Vite
Backend	Rust, Tauri 2
UI Components	shadcn/ui
State Management	Jotai
Search	Tantivy (full-text search)

The combination of Tauri 2 and React provides a lightweight, fast, and native-feeling desktop application with excellent cross-platform support.

Installation

From Release (Recommended)

Download the latest release for your platform from the GitHub Releases page.

Installers are available for:

macOS — .dmg installer
Windows — .exe installer
Linux — .AppImage, .deb, or .rpm packages

From Source

If you prefer to build from source:

# Clone the repository (with submodules)
git clone --recursive https://github.com/markshawn2020/lovcode.git
cd lovcode

# Install dependencies
pnpm install

# Run development mode
pnpm tauri dev

# Build for distribution
pnpm tauri build

Usage Overview

1. Project Selection

On launch, Lovcode scans for Claude Code projects. Select your project to:

View chat history with full-text search
Browse command usage statistics
Access project-specific configurations

2. Configuration Hub

The Configuration section provides centralized access to:

Commands — View and edit slash commands
MCP Servers — Manage server connections
Skills — Configure skill templates
Hooks — Set up automation triggers
Sub-Agents — Manage AI agent configurations
Output Styles — Customize response formatting

3. Command Analytics

Version 0.18.0 introduced command trend charts, showing your usage patterns over time. Track which commands you use most and identify opportunities for optimization.

4. Diagnostics

The diagnostics view provides file statistics and system health information, helping you troubleshoot configuration issues.

Recent Updates

Lovcode is actively maintained with frequent updates:

v0.19.0 (Dec 29, 2025) — Logo generation and management panel, optimized tab group display in collapsed state
v0.18.2 (Dec 28, 2025) — Fixed command statistics data inflation in weekly mode
v0.18.0 (Dec 28, 2025) — Added command trend charts
v0.17.0 (Dec 28, 2025) — Embedded Claude Code and Codex documentation as submodules
v0.16.0 (Dec 27, 2025) — StatuslineView editor and marketplace support
v0.15.0 (Dec 27, 2025) — LLM provider analytics

Why Use Lovcode?

For Individual Developers

Centralized Management — No more digging through ~/.claude directories
Visual Configuration — GUI-based setup for all Claude Code features
Quick Access — Find past conversations and solutions instantly
Better Organization — Keep skills, commands, and hooks organized

For Teams

Consistency — Share configurations and templates across team members
Onboarding — Help new developers understand available tools
Documentation — Built-in documentation for Claude Code and Codex
Standards — Enforce consistent command and skill usage

Comparison with Alternatives

Feature	Lovcode	CLI-only	Web Dashboards
Chat History Search	✓ Full-text	Manual grep	Limited
Visual Config Editor	✓ Native	Text editors	Web forms
Offline Capability	✓ Yes	✓ Yes	✗ No
Native Performance	✓ Yes	✓ Yes	✗ No
Cross-Platform	✓ Yes	✓ Yes	✓ Yes

Community and Contributing

Lovcode is open source under the Apache-2.0 license. Contributions are welcome!

Star the project on GitHub: MarkShawn2020/lovcode
Report Issues via GitHub Issues
Submit Pull Requests for features and fixes

Conclusion

Lovcode fills an important gap in the Claude Code ecosystem by providing a polished desktop interface for managing all aspects of your AI coding assistant. Whether you’re a solo developer looking to organize your configurations or part of a team establishing standards, Lovcode offers the tools you need in a beautiful, performant package.

Download it today from GitHub Releases and take control of your Claude Code workflow.

Links:

GitHub: https://github.com/MarkShawn2020/lovcode
Releases: https://github.com/MarkShawn2020/lovcode/releases
Author: @markshawn2020

Loki Mode: Transform PRDs into Revenue-Generating Products with 37 AI Agents

Dec 29, 2025

Vibe Sparking

Loki Mode: Transform PRDs into Revenue-Generating Products with 37 AI Agents

“Transform a PRD into a fully deployed, revenue-generating product with zero human intervention.”

What if you could turn a single product requirements document into a complete, deployed startup—without writing a single line of code yourself? Meet Loki Mode, a Claude Code skill that orchestrates 37 specialized AI agents across 6 swarms to autonomously build, deploy, and operate entire businesses.

What is Loki Mode?

Loki Mode is a multi-agent autonomous startup system for Claude Code. Just say “Loki Mode” and provide a PRD. The system handles everything:

PRD → Competitive Research → Architecture → Development → Testing → Deployment → Marketing → Revenue

Created by asklokesh, this ambitious project pushes the boundaries of what’s possible with AI agents working in concert.

The Architecture: 37 Agents, 6 Swarms

Loki Mode organizes its AI workforce into specialized swarms, each with a specific domain focus:

Engineering Swarm (8 agents)

eng-frontend - Frontend implementation
eng-backend - Backend services
eng-database - Database architecture
eng-mobile - Mobile development
eng-api - API design and implementation
eng-qa - Quality assurance
eng-perf - Performance optimization
eng-infra - Infrastructure setup

Operations Swarm (8 agents)

ops-devops - CI/CD pipelines
ops-sre - Site reliability engineering
ops-security - Security measures
ops-monitor - Monitoring systems
ops-incident - Incident response
ops-release - Release management
ops-cost - Cost optimization
ops-compliance - Regulatory compliance

Business Swarm (8 agents)

biz-marketing - Marketing strategy
biz-sales - Sales operations
biz-finance - Financial management
biz-legal - Legal considerations
biz-support - Customer support
biz-hr - Human resources
biz-investor - Investor relations
biz-partnerships - Business partnerships

Additional Swarms

Data (3): ML, engineering, analytics
Product (3): PM, design, technical writing
Growth (4): growth hacking, community, success, lifecycle
Review (3): parallel code, business, and security reviewers

Key Features

Category	Capabilities
Multi-Agent System	37 agents across 6 specialized swarms
Parallel Code Review	3 specialized reviewers running simultaneously
Quality Gates	14 automated gates including security scans, load tests, accessibility
Deployment	AWS, GCP, Azure, Vercel, Railway with blue-green and canary strategies
Business Ops	Marketing, Sales, HR, Legal, Finance, Investor Relations agents
Reliability	Circuit breakers, dead letter queues, exponential backoff, state recovery
Observability	External alerting (Slack, PagerDuty), backup/restore, log rotation

Installation

Option A: Download from Releases

cd ~/.claude/skills

# Get latest version
VERSION=$(curl -s https://api.github.com/repos/asklokesh/claudeskill-loki-mode/releases/latest | grep tag_name | cut -d'"' -f4 | tr -d 'v')

# Download and extract
curl -L -o loki-mode.zip "https://github.com/asklokesh/claudeskill-loki-mode/releases/download/v${VERSION}/loki-mode-claude-code-${VERSION}.zip"
unzip loki-mode.zip && rm loki-mode.zip

Option B: Git Clone

# For all projects
git clone https://github.com/asklokesh/claudeskill-loki-mode.git ~/.claude/skills/loki-mode

# For a specific project
git clone https://github.com/asklokesh/claudeskill-loki-mode.git .claude/skills/loki-mode

Option C: Minimal Install

mkdir -p ~/.claude/skills/loki-mode/references
curl -o ~/.claude/skills/loki-mode/SKILL.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/SKILL.md
curl -o ~/.claude/skills/loki-mode/references/agents.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/references/agents.md
curl -o ~/.claude/skills/loki-mode/references/deployment.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/references/deployment.md
curl -o ~/.claude/skills/loki-mode/references/business-ops.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/references/business-ops.md

Usage

Autonomous Runner (Recommended)

The autonomous runner handles everything:

# Run with a PRD (fully autonomous with auto-resume)
./autonomy/run.sh ./docs/requirements.md

# Run interactively
./autonomy/run.sh

The runner:

Checks all prerequisites (Claude CLI, Python, Git, etc.)
Verifies skill installation
Initializes the .loki/ directory
Starts a status monitor (updates every 5 seconds)
Starts Claude Code with live output
Auto-resumes on rate limits or interruptions
Continues until completion or max retries

Manual Mode

# Launch Claude Code with autonomous permissions
claude --dangerously-skip-permissions

# Then say:
> Loki Mode

# Or with a specific PRD:
> Loki Mode with PRD at ./docs/requirements.md

The 8-Phase Execution

Phase	Description
0. Bootstrap	Create `.loki/` directory structure, initialize state
1. Discovery	Parse PRD, competitive research via web search
2. Architecture	Tech stack selection with self-reflection
3. Infrastructure	Provision cloud, CI/CD, monitoring
4. Development	Implement with TDD, parallel code review
5. QA	14 quality gates, security audit, load testing
6. Deployment	Blue-green deploy, auto-rollback on errors
7. Business	Marketing, sales, legal, support setup
8. Growth	Continuous optimization, A/B testing, feedback loops

Quality Assurance

Every task goes through 3 parallel reviewers:

IMPLEMENT → REVIEW (3 parallel) → AGGREGATE → FIX → RE-REVIEW → COMPLETE
                │
                ├─ code-reviewer (opus)
                ├─ business-logic-reviewer (opus)
                └─ security-reviewer (opus)

Severity	Action
Critical/High/Medium	Block. Fix immediately. Re-review.
Low	Add `// TODO(review): ...` comment, continue
Cosmetic	Add `// FIXME(nitpick): ...` comment, continue

Directory Structure

When running, Loki Mode creates:

.loki/
├── state/          # Orchestrator and agent states
├── queue/          # Task queue (pending, in-progress, completed, dead-letter)
├── messages/       # Inter-agent communication
├── logs/           # Audit logs
├── config/         # Configuration files
├── prompts/        # Agent role prompts
├── artifacts/      # Releases, reports, backups
└── scripts/        # Helper scripts

Configuration

Circuit Breakers

defaults:
  failureThreshold: 5
  cooldownSeconds: 300

External Alerting

channels:
  slack:
    webhook_url: "${SLACK_WEBHOOK_URL}"
    severity: [critical, high]

Environment Variables

Variable	Default	Description
`LOKI_MAX_RETRIES`	50	Maximum retry attempts
`LOKI_BASE_WAIT`	60	Base wait time (seconds)
`LOKI_MAX_WAIT`	3600	Maximum wait time (1 hour)
`LOKI_SKIP_PREREQS`	false	Skip prerequisite checks

Testing

Loki Mode includes a comprehensive test suite:

# Run all tests
./tests/run-all-tests.sh

# Individual test suites
./tests/test-bootstrap.sh        # Directory structure, state init
./tests/test-task-queue.sh       # Queue operations, priorities
./tests/test-circuit-breaker.sh  # Failure handling, recovery
./tests/test-agent-timeout.sh    # Timeout, stuck process handling
./tests/test-state-recovery.sh   # Checkpoints, recovery

Example PRDs

The project includes test PRDs in the examples/ directory:

PRD	Complexity	Time	Description
`simple-todo-app.md`	Low	~10 min	Basic todo app - tests core functionality
`api-only.md`	Low	~10 min	REST API only - tests backend agents
`static-landing-page.md`	Low	~5 min	HTML/CSS only - tests frontend/marketing
`full-stack-demo.md`	Medium	~30-60 min	Complete bookmark manager - full test

Comparison: Basic Skills vs Loki Mode

Feature	Basic Skills	Loki Mode
Agents	1	37
Swarms	-	6
Code Review	Manual	Parallel 3-reviewer
Deployment	None	Multi-cloud
Business Ops	None	Full stack
State Recovery	None	Checkpoint/resume
Alerting	None	Slack/PagerDuty

Integrations

Vibe Kanban

Optionally integrate with Vibe Kanban for visual task monitoring:

npx vibe-kanban
./scripts/export-to-vibe-kanban.sh

Benefits:

Visual progress tracking of all 37 agents
Manual intervention/prioritization when needed
Code review with visual diffs
Multi-project dashboard

Requirements

Claude Code with --dangerously-skip-permissions flag
Internet access for competitive research and deployment
Cloud provider credentials (for deployment phase)
Python 3 (for test suite)

Current Status

Loki Mode is actively developed with recent releases including:

Codebase Analysis Mode (v2.7.0)
Unified autonomy runner (v2.3.0)
Vibe Kanban integration (v2.2.0)
Autonomous wrapper with auto-resume (v2.1.0)

License & Acknowledgments

License: MIT
Inspired by: LerianStudio/ring subagent-driven-development pattern
Built for: Claude Code ecosystem

Getting Started

Ready to let AI build your next startup?

Install Loki Mode using one of the methods above
Create a PRD describing your product idea
Run ./autonomy/run.sh your-prd.md
Watch as 37 agents collaborate to bring your vision to life

The future of autonomous development is here—and it speaks fluent Claude.

Project Repository: asklokesh/claudeskill-loki-mode

Keywords: claude-code, claude-skills, ai-agents, autonomous-development, multi-agent-system, sdlc-automation, startup-automation, devops, mlops, deployment-automation

Quotio: Stop Juggling AI Accounts - A macOS Menu Bar App That Unifies Claude, Gemini, OpenAI, Qwen, and Antigravity

Dec 28, 2025

Vibe Sparking

Quotio: Stop Juggling AI Accounts

Stop juggling AI accounts. Quotio is a beautiful native macOS menu bar app that unifies your Claude, Gemini, OpenAI, Qwen, and Antigravity subscriptions – with real-time quota tracking and smart auto-failover for AI coding tools like Claude Code, OpenCode, and Droid.

Introduction: The AI Account Management Problem

As developers, we increasingly rely on multiple AI coding assistants in our daily work. You might use Claude Code for intelligent code completion, GitHub Copilot for inline suggestions, Cursor for AI-powered IDE features, and various OpenAI-based tools for different tasks. Each service comes with its own:

Subscription and billing
API keys and authentication
Usage quotas and rate limits
Separate dashboard and management interface

This fragmentation creates constant overhead. You’re juggling multiple browser tabs, switching between different CLI configurations, and inevitably hitting rate limits on one service while another sits idle. Enter Quotio – a unified solution that brings all your AI subscriptions under one roof.

What is Quotio?

Quotio is a native macOS application that provides unified quota monitoring and request routing for multiple AI provider services. Created by developer Trong Nguyen (nguyenphutrong), Quotio serves two complementary purposes:

Visual Dashboard – Track all your AI API usage limits in one beautiful interface
Optional Local Proxy – Route requests across multiple provider accounts with intelligent load balancing and failover

Dual-Mode Architecture

Quotio offers two operation modes to suit different needs:

Quota-Only Mode

A lightweight mode perfect for users who simply want visibility into their AI usage:

Real-time quota tracking by reading authentication files from installed CLI tools
Support for Claude Code, Codex CLI, Gemini CLI, GitHub Copilot, Cursor, and Antigravity
macOS menu bar integration for at-a-glance quota status
System notifications for low quota warnings
No proxy server required – minimal resource footprint

Full Mode

All Quota-Only features plus powerful proxy capabilities:

Local proxy server for request routing and load balancing
OAuth-based provider authentication
Automatic failover between accounts when quotas are exhausted
API key management for secure proxy access
Comprehensive usage statistics and request logging
Automatic configuration of CLI agents to use the proxy

Core Features

1. Multi-Provider Support

Quotio unifies 10 AI providers in a single interface:

Provider	Quota-Only Mode	Full Mode
Claude	✅	✅
Gemini	✅	✅
OpenAI	✅	✅
Qwen	✅	✅
Antigravity	✅	✅
GitHub Copilot	✅	✅
Cursor	✅	✅
Codex CLI	✅	✅

2. Real-Time Quota Tracking

The menu bar integration provides at-a-glance quota status:

Provider symbol (1-2 letters) + lowest percentage across models
Example: "G:95% C:42% CP:88%" (Gemini 95%, Claude 42%, Copilot 88%)
Color-coded indicators: green (>50%), orange (20-50%), red (<20%)
Customizable display options – show/hide providers, change color modes

3. Smart Auto-Failover

In Full Mode, Quotio acts as an intelligent proxy:

┌─────────────────┐
│  Coding Tool    │
│  (Claude Code)  │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Quotio Proxy   │
│  (localhost)    │
└────────┬────────┘
         │
         ▼
┌─────┬─────┬─────┬─────┐
│ Claude│Gemini│OpenAI│Qwen│
│ Acct 1│Acct 1│Acct 1│Acct 1│
└─────┴─────┴─────┴─────┘
    (Auto-failover when quota exhausted)

When one account hits its quota limit, Quotio automatically routes requests to another available account, ensuring uninterrupted workflow.

The persistent macOS menu bar presence keeps you informed without interrupting your workflow:

Always-visible quota status
Quick access to detailed dashboard
Low quota notifications
Language support: English and Vietnamese

Installation and Setup

Prerequisites

macOS 14.6 or later
Accounts with supported AI providers (Claude, Gemini, OpenAI, etc.)

Getting Started

Download Quotio from the GitHub Releases page
Launch the app and complete the onboarding flow
Choose your mode: Quota-Only (lightweight) or Full (with proxy)
Connect your accounts via OAuth or manual authentication
Configure your coding tools to use the Quotio proxy (Full Mode)

Agent Configuration

For AI coding tools, Quotio provides automatic configuration:

# Quotio can auto-configure these tools:
- Claude Code
- OpenCode
- Droid
- Cursor

Use Cases and Best Practices

For Individual Developers

Scenario: You’re a developer using Claude Code for daily work, but you also have access to Gemini and OpenAI APIs for side projects.

Solution: Quotio lets you see all your quotas at a glance and automatically routes requests when one provider is exhausted.

For Teams

Scenario: Your team has multiple AI subscriptions across different providers, and team members frequently hit rate limits during peak hours.

Solution: Configure Quotio with multiple accounts per provider for intelligent load distribution and automatic failover.

For Cost Optimization

Scenario: You want to maximize usage of your AI subscriptions before upgrading to higher tiers.

Solution: Use Quotio’s detailed usage statistics to understand consumption patterns and make informed decisions about subscription upgrades.

Technical Architecture

Built with modern macOS development practices:

Framework: SwiftUI with AppKit integration
Architecture: MVVM with Actor Model for thread-safe services
Concurrency: Swift Concurrency (async/await, actors)
Localization: English and Vietnamese support
Auto-Updates: Sparkle framework for seamless updates

The project structure follows clean architecture principles:

Quotio/
├── Models/           # Core data structures
├── ViewModels/       # @Observable state managers
├── Views/            # SwiftUI screens and components
├── Services/         # Quota fetchers, proxy manager, API clients
└── Managers/         # Singletons for app-wide coordination

Comparison with Alternatives

Feature	Quotio	Manual Management	Other Solutions
Multi-Provider Support	✅ 10+ providers	❌ One at a time	⚠️ Limited
Real-Time Quota Tracking	✅ Menu bar + dashboard	❌ Browser tabs only	⚠️ Often delayed
Auto-Failover	✅ Intelligent routing	❌ Manual switching	⚠️ Basic routing
Native macOS App	✅ Menu bar integration	❌ Web-based	⚠️ Electron bloat
Open Source	✅ Fully open source	N/A	❌ Often proprietary
Offline Capable	✅ Works without internet	❌ Requires internet	⚠️ Limited

Future Roadmap

As of version 0.2.2, Quotio is actively developed with recent additions including:

Quota-Only Mode for lightweight usage
Cursor support
Enhanced proxy management
Internationalization support

Check the CHANGELOG.md for the latest updates.

Conclusion

Quotio solves a real pain point for developers who use multiple AI services. By providing unified quota monitoring, intelligent request routing, and seamless failover, it transforms the fragmented experience of managing multiple AI subscriptions into a cohesive, productive workflow.

Whether you’re an individual developer juggling personal AI subscriptions or part of a team with multiple provider accounts, Quotio offers the tools you need to maximize your AI productivity.

Download Quotio today: github.com/nguyenphutrong/quotio

References

WeChat Article Writer: Automate WeChat Public Account Content with Claude Code

Dec 28, 2025

Vibe Sparking

WeChat Article Writer: Automate WeChat Public Account Content with Claude Code

Creating engaging content for WeChat public accounts (公众号) is a time-consuming process that involves research, writing, headline optimization, and formatting. The wechat-article-writer skill for Claude Code automates this entire workflow, allowing content creators to produce professional articles in minutes rather than hours.

WeChat Article Writer

What is wechat-article-writer?

wechat-article-writer is a Claude Code skill from the happy-claude-skills collection that automates the entire WeChat public account article creation process. It handles:

Research - Multi-source web search for latest information
Writing - AI-powered content generation with storytelling elements
Headlines - Viral title generation with proven formulas
Formatting - Professional layout optimized for mobile reading

GitHub Repository: iamzhihuix/happy-claude-skills License: MIT

The 4-Step Workflow

Step 1: Research (搜索资料)

The skill automatically searches multiple sources in parallel:

Official documentation
Social media (X/Twitter, Reddit)
Technical forums and communities
Latest monthly/quarterly content

It uses Claude Code’s built-in WebSearch tool and can spawn parallel tasks to accelerate information gathering.

Step 2: Writing (撰写文章)

Content generation follows best practices for WeChat articles:

Length: 1000-1500 words (optimal for mobile reading)
Opening: Story-driven with emotional hooks (excitement/anxiety/curiosity)
Structure: Effect showcase → Problem description → Tutorial → Conclusion
Style: Reads your CLAUDE.md to match your personal writing style

Step 3: Viral Headlines (生成标题)

Generates 5 viral headlines using proven techniques:

Pain points: “Still doing X manually?”
Numbers: “3 minutes”, “5 tips” - specific digits are persuasive
Results: “Efficiency up 10x”
Emotion: “Amazing”, “Secret weapon”, “Ultimate guide”
Curiosity: Headlines that make readers want to click

Step 4: Formatting (排版优化)

Mobile-optimized layout recommendations:

Short paragraphs (3-5 lines each)
Key data points in bold, standalone paragraphs
Strategic image placement (cover, step illustrations, conclusion)
Code blocks with proper spacing and syntax highlighting
“Golden quotes” - memorable phrases set apart for impact

Installation

Prerequisites

Claude Code installed
Access to Claude Skills feature

Install from Repository

# Add the happy-claude-skills marketplace
/plugin marketplace add iamzhihuix/happy-claude-skills

# Install the wechat-article-writer skill
/plugin install wechat-article-writer@happy-claude-skills

Usage

Once installed, simply describe your article needs:

Help me write a WeChat article about AI programming tips

Claude Code will automatically:

Detect the request matches the wechat-article-writer skill
Search for latest AI programming trends and tips
Read your CLAUDE.md to match your writing style
Generate a 1200-word tutorial article
Provide 5 viral headline options
Suggest formatting and image placement

Example Workflow

Input:

Write a WeChat article about the new Claude Code features

Output:

Research Summary: Latest Claude Code updates from official docs, Twitter discussions, and community forums
Article: 1200-word tutorial with story-driven opening
5 Headlines:
- “Still manually copying code? This Claude feature will change your life”
- “3 minutes to master Claude Code’s hidden superpower”
- “Productivity up 10x: The Claude Code feature pros don’t talk about”
- “Amazing! Claude Code can now do this automatically”
- “The ultimate Claude Code workflow nobody knows about”
Layout Guide: Image placement suggestions, formatting recommendations

Key Features

Multi-Source Research

The skill searches across multiple platforms in parallel, ensuring your content is well-researched and up-to-date.

Personalized Writing Style

By reading your CLAUDE.md file, the skill adapts to your established voice and tone, maintaining consistency across your content.

Viral Optimization

Headline generation uses data-backed formulas from successful WeChat articles, maximizing click-through rates.

Mobile-First Formatting

Layout recommendations are specifically designed for WeChat’s mobile interface, where most readers consume content.

Use Cases

Tech Bloggers: Quick turnaround on trending topics
Marketing Teams: Consistent brand voice across all content
Individual Creators: Scale content production without sacrificing quality
News Aggregators: Curate and synthesize information efficiently

Project Structure

happy-claude-skills/
└── skills/
    └── wechat-article-writer/
        ├── SKILL.md          # Main skill definition
        ├── skill.config.json # Configuration
        └── README.md         # Documentation

Contributing

The happy-claude-skills project is open source. Contributions are welcome:

Fork the repository
Create a feature branch
Submit a pull request

Repository: https://github.com/iamzhihuix/happy-claude-skills

Comparison with Alternatives

Feature	wechat-article-writer	Manual Writing	Other AI Tools
Research automation	✓ Multi-source	✗ Manual	✗ Limited
WeChat optimization	✓ Native	✓ Manual	✗ Generic
Style adaptation	✓ CLAUDE.md	N/A	✗ Fixed
Headline formulas	✓ 5 viral options	✗ Manual	✗ Basic
Integration	✓ Claude Code native	N/A	✗ Copy/paste

Limitations

Requires Claude Code and access to Claude Skills
Chinese-language optimized (WeChat specific)
Output quality depends on search result availability
Requires manual review and editing for best results

Future Enhancements

Potential improvements being considered:

Direct publishing to WeChat API
Multi-language support beyond Chinese
Image generation integration
Analytics tracking integration

Conclusion

The wechat-article-writer skill transforms WeChat content creation from a multi-hour process into a streamlined workflow. By combining research, writing, headline optimization, and formatting into a single automated flow, it helps creators maintain consistency and quality while scaling production.

For Claude Code users who manage WeChat public accounts or create content in Chinese, this skill is a valuable addition to the toolkit.

Links

GitHub: iamzhihuix/happy-claude-skills
Claude Code: https://claude.ai/code
Claude Skills Documentation: https://support.claude.com/en/articles/12512180-using-skills-in-claude

Happy Claude Skills: Practical Plugin Collection for Claude Code

Dec 28, 2025

Vibe Sparking

Happy Claude Skills: Practical Plugin Collection for Claude Code

Claude Code’s plugin system allows developers to extend its capabilities with custom skills. While the official marketplace is growing, the community has already started creating useful plugins. One such contribution is happy-claude-skills by iamzhihuix, a collection of three practical skills for common productivity tasks.

Happy Claude Skills

What is happy-claude-skills?

happy-claude-skills is an open-source collection of skill plugins designed for Claude Code. It currently includes three skills:

docx-format-replicator - Extract and replicate Word document formatting
video-processor - Download and process videos from YouTube and other platforms
wechat-article-writer - Automated WeChat article writing workflow

GitHub Repository: iamzhihuix/happy-claude-skills Author: iamzhihuix License: MIT

Installation

Method 1: Plugin Marketplace (Recommended)

Add the repository as a plugin marketplace in Claude Code:

/plugin marketplace add iamzhihuix/happy-claude-skills

Then install individual skills:

/plugin install docx-format-replicator@happy-claude-skills
/plugin install video-processor@happy-claude-skills
/plugin install wechat-article-writer@happy-claude-skills

Method 2: Local Development

Clone and use directly:

git clone https://github.com/iamzhihuix/happy-claude-skills.git
claude --plugin-dir /path/to/happy-claude-skills

Skill 1: docx-format-replicator

Extract formatting from existing Word documents and generate new documents with the same format.

Use Cases

Corporate document template replication - Maintain consistent branding across documents
Batch document generation - Create multiple documents with identical formatting
Technical specification series - Generate spec documents from templates
Standardized documentation - Development task sheets, reports, etc.

Installation

pip install python-docx

Usage Example

After installation, simply describe your needs in Claude Code:

“I have a document template and need to generate 5 new documents with the same format”

Claude will automatically identify and invoke the appropriate skill.

Skill 2: video-processor

Download and process videos from YouTube and other platforms. Supports video download, audio extraction, format conversion, and Whisper transcription.

Use Cases

Download videos from YouTube and other platforms
Extract audio from video files
Convert videos to MP4/WebM formats
Transcribe audio/video to text using Whisper

Dependencies

# Python packages
pip install yt-dlp openai-whisper

# FFmpeg (macOS)
brew install ffmpeg

Usage Example

“Download this YouTube video and transcribe it to text”

“Extract the audio from this video file”

Skill 3: wechat-article-writer

Automated WeChat article writing workflow with 4 steps: research, writing, title generation, and formatting optimization.

Use Cases

Write WeChat official account articles
Generate viral headlines
Content creation for self-media
Article formatting and optimization

Workflow

The skill follows a 4-step process:

Research - Gather information on the topic
Writing - Generate article content
Title Generation - Create engaging headlines
Formatting - Optimize for WeChat’s editor

Usage Example

“Help me write a WeChat article about AI programming tips”

Project Structure

happy-claude-skills/
├── .claude-plugin/
│   └── marketplace.json         # Marketplace configuration
├── skills/
│   ├── docx-format-replicator/
│   │   ├── SKILL.md             # Skill definition
│   │   ├── scripts/             # Python scripts
│   │   ├── assets/              # Example files
│   │   └── references/          # Reference docs
│   ├── video-processor/
│   │   ├── SKILL.md             # Skill definition
│   │   └── scripts/             # Python scripts
│   └── wechat-article-writer/
│       └── SKILL.md             # Skill definition
├── README.md
└── LICENSE

Acknowledgments

The video-processor skill is adapted from claude-code-hooks-multi-agent-observability by disler.

Why These Skills Matter

Claude Code’s plugin system enables community contributions that extend the tool’s capabilities beyond its core features. The happy-claude-skills collection demonstrates practical applications:

Document automation - Reduces manual formatting work
Media processing - Brings video handling capabilities into the coding workflow
Content creation - Streamlines article writing for Chinese audiences

As the Claude Code ecosystem grows, we can expect more community plugins to emerge, further enhancing the tool’s versatility.

Contributing

The project is open to contributions. If you have ideas for new skills or improvements:

Fork the repository
Create your skill following the existing structure
Submit a pull request

Links:

Claude Code Transcripts: Publish Your AI Coding Sessions as HTML

Dec 28, 2025

Vibe Sparking

Claude Code Transcripts: Publish Your AI Coding Sessions as HTML

When using Claude Code for software development, every session contains valuable insights — debugging approaches, architectural decisions, and problem-solving techniques. But these conversations are locked away in JSON files buried in ~/.claude/projects.

Simon Willison has released claude-code-transcripts, a Python CLI tool that converts these session files into beautiful, browsable HTML transcripts that can be shared with others.

Claude Code Transcripts

What is claude-code-transcripts?

claude-code-transcripts is a command-line tool that converts Claude Code session data (stored as JSON or JSONL files) into paginated, mobile-friendly HTML transcripts. It provides:

Better readability than the raw Claude Code interface
Shareable output that works with any static hosting or GitHub Gists
Multiple input sources: local sessions, web sessions via API, or direct JSON files
Clean, organized layout with pagination for long sessions

GitHub Repository: simonw/claude-code-transcripts Author: Simon Willison License: Apache 2.0 PyPI: claude-code-transcripts

Installation

The tool can be installed using uv (recommended) or run directly without installation:

# Install using uv
uv tool install claude-code-transcripts

# Or run without installation
uvx claude-code-transcripts --help

Four Main Commands

The tool provides four commands for different use cases:

1. `local` (default) - Browse Local Sessions

Convert sessions stored locally in ~/.claude/projects:

# Interactive picker for recent sessions
claude-code-transcripts

# Explicit local command
claude-code-transcripts local

# Show more sessions in the picker
claude-code-transcripts local --limit 20

2. `web` - Import from Claude API

Fetch sessions directly from the Claude web API:

# Interactive session picker
claude-code-transcripts web

# Import specific session by ID
claude-code-transcripts web SESSION_ID

On macOS, credentials are automatically retrieved from your keychain. On other platforms, use --token and --org-uuid.

3. `json` - Convert Specific Files

Convert a JSON or JSONL session file directly:

claude-code-transcripts json session.json -o output-directory/
claude-code-transcripts json session.jsonl --open

4. `all` - Archive All Sessions

Convert all local sessions into a browsable HTML archive:

claude-code-transcripts all

This creates a directory structure with:

A master index listing all projects
Per-project pages listing sessions
Individual session transcripts

Output Options

All commands support these useful options:

Option	Description
`-o, --output DIR`	Output directory (default: temp dir + open browser)
`-a, --output-auto`	Auto-name subdirectory based on session ID
`--repo OWNER/NAME`	GitHub repo for commit links
`--open`	Open generated HTML in default browser
`--gist`	Upload to GitHub Gist and return preview URL
`--json`	Include original session file in output

Publishing to GitHub Gist

One of the most powerful features is the --gist option:

# Publish transcript as a Gist
claude-code-transcripts --gist

# Import from web and publish
claude-code-transcripts web SESSION_ID --gist

# Convert specific file and publish
claude-code-transcripts json session.json --gist

This requires the GitHub CLI to be installed and authenticated. The output includes:

Gist: https://gist.github.com/username/abc123def456
Preview: https://gistpreview.github.io/?abc123def456/index.html
Files: /var/folders/.../session-id

Example Output

The tool generates:

index.html - Timeline page with prompts and commits
page-001.html, page-002.html, etc. - Paginated transcript pages

See an example transcript created by Simon.

Use Cases

Documentation - Turn complex debugging sessions into reference documentation
Knowledge Sharing - Share architectural decisions with your team
Tutorials - Create step-by-step guides from real coding sessions
Archiving - Build a searchable archive of your development work
Blogging - Transform interesting sessions into blog posts

Technical Details

Input Sources: Local ~/.claude/projects, Claude Web API, or JSON/JSONL files
Output Format: Static HTML with CSS, no build step required
Dependencies: Python 3.8+, minimal dependencies
Platform Support: macOS, Linux, Windows

Comparison with Alternatives

Feature	claude-code-transcripts	claude-notes
GitHub Gist integration	✅ Built-in	❌ No
Web API support	✅ Yes	❌ Local only
Archive all sessions	✅ Yes	❌ Per-file only
Mobile-friendly	✅ Yes	✅ Yes
Pagination	✅ Yes	✅ Yes

Both tools serve similar purposes, but claude-code-transcripts offers more advanced features for sharing and publishing.

Conclusion

claude-code-transcripts fills an important gap in the Claude Code ecosystem by making sessions shareable and readable outside the Claude Code interface. Whether you’re documenting your work, sharing with colleagues, or building a knowledge base, this tool transforms ephemeral AI conversations into permanent, valuable resources.

Links:

Claude Code Board: Use Claude Code on Kanban WebUI

Dec 26, 2025

Vibe Sparking

Introduction

Claude Code Board is a web-based Kanban-style management interface designed specifically for the Claude Code CLI. If you are a power user of Claude Code, you might find yourself juggling multiple terminal windows to handle different tasks concurrently. Claude Code Board solves this by providing a unified, visual interface to manage these sessions.

It aims to enhance the developer experience by allowing concurrent management of multiple AI coding sessions with real-time status tracking (idle, processing, completed, error).

Features

Multi-Session Management

Run multiple Claude Code instances simultaneously. The Kanban board allows you to see the status of each session at a glance—whether it’s idle, processing, or completed.

Advanced AI Workflows

Agent Integration: Load custom Claude agents directly from your ~/.claude/agents/ directory.
Workflow Stages: Utilize pre-configured stages like Code Review, Bug Fixing, and Feature Development to structure your work.
Smart Prompting: Automatically inject agent instructions and custom templates to streamline your interaction with the AI.

Project Organization

Group your sessions under “Work Items,” tag them by project or topic, and automatically manage workspace paths. This keeps your work organized conceptually, not just by terminal ID.

Enhanced UI/UX

WebSocket-powered chat: Real-time updates and interaction.
Notifications: Windows Toast notifications alert you when a task is completed.
Message Filtering: Filter out “thinking” blocks or tool use logs to focus on the conversation and results.
Session Recovery: Resume previous conversations with full context preservation.

Prerequisites and Installation

Prerequisites

Operating System: Windows 10/11
Runtime: Node.js (v18+)
Core Tool: Claude Code CLI installed globally (npm install -g @anthropic-ai/claude-code)

Installation Steps

Clone the Repository

git clone https://github.com/cablate/Claude-Code-Board.git
cd Claude-Code-Board

Install Dependencies You need to install dependencies for the root, backend, and frontend.
Terminal window
```
npm install
cd backend && npm install
cd ../frontend && npm install
```
Start the Application
- Option 1 (Windows): Simply run start.bat.
- Option 2 (Manual): Run npm run dev:backend and npm run dev:frontend in separate terminals.
Access: Open your browser and navigate to http://localhost:5173.

Usage Scenarios

Concurrent Development

Imagine you are working on a feature, but you also need to fix a critical bug and review a PR. Instead of opening three terminals and losing track of context, you can create three cards on the Claude Code Board: “Feature X”, “Bug Y”, and “PR Review Z”. You can switch between them easily and see their progress.

Agent-Based Workflows

You can configure specialized agents (e.g., an “Architect” agent or a “Debugger” agent) by creating .md files in your agents directory. When starting a session, you can select the specific agent best suited for the task.

Precautions

Security: This tool is designed for local/personal use only. It does not have enterprise-grade security (encryption/auth) and should not be deployed to public networks.
Platform: Currently optimized for Windows.

Reference Links

Claude Code Board GitHub Repository

GLM Coding Plan in Claude Code: Zhipu AI Integration Guide

Dec 26, 2025

Vibe Sparking

Use Zhipu AI’s GLM models in Claude Code with the official GLM Coding Plan integration. A complete guide to installation, configuration, and daily usage.

Introduction

Claude Code is an intelligent coding tool that runs in the terminal, helping developers quickly complete code generation, debugging, refactoring, and other tasks through natural language commands. But what if you want to use China’s powerful GLM models instead?

GLM Coding Plan is the official solution from Zhipu AI that integrates GLM models directly into Claude Code. With this integration, you can leverage models like GLM-4.7 and GLM-4.5-Air while keeping the familiar Claude Code workflow.

This guide covers everything you need to know: from installation to advanced configuration, troubleshooting, and best practices.

Quick Start (3 Steps)

Prerequisites

Before you begin, ensure you have:

Node.js 18 or newer installed
Git for Windows (Windows users only)
A Zhipu AI account with API access

Step 1: Install Claude Code

Open your terminal and run:

npm install -g @anthropic-ai/claude-code

Verify the installation:

claude --version
# Output: 2.0.14 (Claude Code) or higher

Tip: If you’re not familiar with Node.js and have Cursor installed, you can type Help me install Claude Code in Cursor, and it will guide you through the installation process.

Step 2: Configure GLM Coding Plan

Zhipu AI provides two integration approaches:

Approach A: Environment Variables (Quick Start)

Set the following environment variables in your terminal:

export ANTHROPIC_BASE_URL="https://open.bigmodel.cn/api/paas/v4/"
export ANTHROPIC_AUTH_TOKEN="your_zhipu_api_key"
export ANTHROPIC_MODEL="glm-4.7"

Or add them to your shell config (~/.zshrc or ~/.bashrc):

cat >> ~/.zshrc <<'EOF'
# GLM Coding Plan Configuration
export ANTHROPIC_BASE_URL="https://open.bigmodel.cn/api/paas/v4/"
export ANTHROPIC_AUTH_TOKEN="your_zhipu_api_key"
export ANTHROPIC_MODEL="glm-4.7"
EOF

source ~/.zshrc

Approach B: Settings File (Recommended)

Edit ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://open.bigmodel.cn/api/paas/v4/",
    "ANTHROPIC_AUTH_TOKEN": "your_zhipu_api_key",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.7",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.7"
  }
}

Step 3: Start Coding with GLM

Navigate to your project directory and run:

claude

When prompted “Do you want to use this API key?”, select Yes. Then trust Claude Code to access your project files.

Available GLM Models

Model	Use Case	Speed	Quality
GLM-4.7	Complex reasoning, architecture design	Medium	Highest
GLM-4.5-Air	Quick tasks, simple queries	Fast	Good
GLM-4.5	Balanced performance	Medium	High

Model Selection Strategy

Use GLM-4.7 for: feature implementation, code refactoring, architectural decisions
Use GLM-4.5-Air for: quick fixes, documentation, simple queries
Use GLM-4.5 for: general development tasks

Daily Workflow Examples

Scenario 1: Feature Development

# Navigate to your project
cd my-project

# Start Claude Code with GLM
claude

# In Claude Code:
> Add user authentication with JWT tokens
> Write unit tests for the auth module
> Review and optimize the database queries

Scenario 2: Code Refactoring

claude

# In Claude Code:
> Refactor the User class to follow SOLID principles
> Extract the validation logic into a separate service
> Add TypeScript types to the entire module

Scenario 3: Debugging

claude

# In Claude Code:
> Investigate why the API returns 500 errors
> Add comprehensive error logging
> Write a test case for this bug

Advanced Configuration

Switching Models On-the-Fly

You can switch models without restarting Claude Code by modifying the environment variable:

# Switch to faster model for quick tasks
export ANTHROPIC_MODEL="glm-4.5-air"

# Switch to more powerful model for complex tasks
export ANTHROPIC_MODEL="glm-4.7"

Then verify with /status in Claude Code:

Current model: glm-4.7
Base URL: https://open.bigmodel.cn/api/paas/v4/

MCP Server Integration

GLM Coding Plan supports additional MCP servers for enhanced capabilities:

Vision MCP Server

Enable image understanding capabilities:

{
  "mcpServers": {
    "vision": {
      "command": "node",
      "args": ["path/to/vision-mcp-server.js"]
    }
  }
}

Search MCP Server

Add web search capabilities:

{
  "mcpServers": {
    "search": {
      "command": "node",
      "args": ["path/to/search-mcp-server.js"]
    }
  }
}

Web Reader MCP Server

Enable web page reading:

{
  "mcpServers": {
    "web-reader": {
      "command": "node",
      "args": ["path/to/web-reader-mcp.js"]
    }
  }
}

Troubleshooting

Issue: Configuration Changes Not Applied

Symptoms: You modified ~/.claude/settings.json but changes don’t take effect.

Solutions:

Restart Claude Code completely - Close all terminal windows and start fresh:
Terminal window
```
claude
```
Verify JSON syntax - Use a JSON validator to check for syntax errors:
Terminal window
```
cat ~/.claude/settings.json | python -m json.tool
```

Reset configuration - Delete the file and reconfigure:

rm ~/.claude/settings.json
claude  # Will prompt for reconfiguration

Issue: API Key Authentication Fails

Symptoms: “Unauthorized” or “Invalid API key” errors.

Solutions:

Verify your API key in the Zhipu AI Console
Check for extra spaces or quotes in your environment variables
Ensure the ANTHROPIC_AUTH_TOKEN is set correctly

Issue: Slow Response Times

Symptoms: GLM models take too long to respond.

Solutions:

Switch to glm-4.5-air for faster responses

Increase timeout if needed:

export API_TIMEOUT_MS=600000  # 10 minutes

Check your network connection to the Zhipu API

Best Practices

1. Model Selection for Task Type

Task Type	Recommended Model
Quick fixes	GLM-4.5-Air
Feature implementation	GLM-4.7
Code review	GLM-4.7
Documentation	GLM-4.5-Air
Debugging	GLM-4.7
Simple queries	GLM-4.5-Air

2. Project Structure Awareness

Always run Claude Code from your project root directory. This helps Claude understand:

Project structure and dependencies
Build configurations
Test setups
Coding conventions

3. Iterative Development

Break complex tasks into smaller steps:

1. "Create the user schema"
2. "Add CRUD operations for users"
3. "Write tests for user operations"
4. "Add input validation"
5. "Document the API endpoints"

4. Leverage Context

Claude Code works best when you provide context:

Share error messages completely
Show relevant code snippets
Explain the business requirements
Describe expected behavior

Recommended Claude Code Version

Zhipu AI validates GLM Coding Plan on Claude Code 2.0.14+. To check and upgrade:

# Check current version
claude --version

# Upgrade to latest version
claude update

Always keep Claude Code updated for the best compatibility with GLM models.

Comparison: GLM vs Other Options

Feature	GLM Coding Plan	Direct Anthropic	Other China LLMs
Setup Complexity	Low	Medium	Varies
Chinese Understanding	Excellent	Good	Excellent
Code Quality	High	Very High	Medium-High
Cost	Competitive	Higher	Varies
Local Data	Yes	No	Varies
Official Support	Yes	N/A	Limited

FAQ

Q: Can I use GLM Coding Plan alongside other Claude Code configurations?

A: Yes, you can switch between different API providers by changing environment variables or creating multiple profiles in your settings file.

Q: Is my code data sent to Zhipu AI servers?

A: Yes, similar to how Claude Code sends data to Anthropic. Review Zhipu AI’s data privacy policy for details on data handling and retention.

Q: Can I use GLM Coding Plan in Cursor or other IDEs?

A: GLM Coding Plan is primarily designed for terminal-based Claude Code. However, you can configure similar API settings in Cursor if it supports custom endpoints.

Q: What’s the difference between GLM-4.7 and GLM-4.5-Air?

A: GLM-4.7 is Zhipu’s most capable model for complex reasoning tasks, while GLM-4.5-Air is optimized for speed and cost efficiency on simpler tasks.

Q: How do I check which model is currently active?

A: Run /status command in Claude Code to see the current model and configuration.

Reference Links

Conclusion

GLM Coding Plan brings the power of Zhipu AI’s GLM models to Claude Code, offering a compelling alternative for developers who prefer China-hosted models or need better Chinese language understanding. With proper configuration and model selection, you can achieve productivity gains while maintaining data locality.

The integration is straightforward, the documentation is comprehensive, and the official support from Zhipu AI ensures a smooth experience. Whether you’re building new features or debugging existing code, GLM Coding Plan has you covered.

Happy coding with GLM!

Superpowers: Transform Claude Code Into a Disciplined Development Workflow Engine

Dec 26, 2025

Vibe Sparking

Introduction

What if Claude Code could enforce engineering discipline instead of just writing code? That’s exactly what obra/superpowers delivers—a complete software development workflow system built on composable “skills” that automatically activate to guide your development process.

With over 11,800 stars and 960 forks on GitHub, Superpowers has become the go-to framework for developers who want their AI coding assistant to follow systematic engineering practices rather than ad-hoc code generation.

Claude Code Superpowers Workflow

The Core Philosophy: Engineering Discipline Over Quick Fixes

Superpowers enforces four fundamental principles:

Principle	Description
Test-Driven Development	Write tests first, always. Code written before tests may be deleted
Systematic over Ad-hoc	Follow defined processes rather than guessing
Complexity Reduction	Simplicity as the primary goal (YAGNI, DRY)
Evidence over Claims	Verify fixes work before declaring success

This isn’t about adding more features—it’s about fundamentally changing how AI agents approach software development.

How Superpowers Works: The Five-Phase Workflow

When you start a project with Superpowers enabled, Claude Code follows a structured workflow:

Phase 1: Design First (Brainstorming)

Instead of immediately writing code, the agent “steps back and asks what you’re really trying to do.” Through Socratic dialogue, it:

Explores your requirements through questions
Considers alternatives and edge cases
Presents design in digestible chunks for approval
Saves a specification document

Phase 2: Planning

After design approval, it creates an implementation plan that’s “clear enough for an enthusiastic junior engineer” to follow:

Breaks work into 2-5 minute tasks
Specifies exact file paths and code locations
Includes verification steps for each task
Emphasizes TDD, YAGNI, and DRY principles

Phase 3: Isolated Development (Git Worktrees)

The system creates isolated workspaces:

# Superpowers automatically:
# 1. Creates a new branch via git worktree
# 2. Runs project setup
# 3. Verifies test baseline (all tests must pass before changes)

Phase 4: Subagent Execution

Here’s where the magic happens—autonomous execution with quality gates:

Fresh subagents handle individual tasks
Two-stage review: specification compliance, then code quality
The docs note: “It’s not uncommon for Claude to work autonomously for a couple hours at a time”

Phase 5: Completion

Verifies all tests pass
Offers merge or PR options
Cleans up worktrees
Presents summary with code review prompt

Installation: Quick Start Guide

For Claude Code (Plugin System)

# 1. Register the marketplace
/plugin marketplace add obra/superpowers-marketplace

# 2. Install superpowers
/plugin install superpowers@superpowers-marketplace

# 3. Verify installation
/help
# You should see: /superpowers:brainstorm, /superpowers:write-plan, /superpowers:execute-plan

For Codex

Tell Codex to fetch and follow:

https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

For OpenCode

Tell OpenCode to fetch and follow:

https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md

Updating

/plugin update superpowers

The Complete Skills Library

Superpowers includes a comprehensive set of skills organized by category:

Testing Skills

Skill	Purpose
`test-driven-development`	Enforces RED-GREEN-REFACTOR cycle with anti-patterns reference

Debugging Skills

Skill	Purpose
`systematic-debugging`	4-phase root cause analysis process
`verification-before-completion`	Ensures fixes are actually verified before marking complete

Collaboration Skills

Skill	Purpose
`brainstorming`	Interactive Socratic design refinement
`writing-plans`	Creates detailed implementation plans with exact file paths
`executing-plans`	Batch execution with human checkpoints
`dispatching-parallel-agents`	Manages concurrent subagent workflows
`requesting-code-review`	Pre-review checklist system
`receiving-code-review`	Structured feedback response workflow
`using-git-worktrees`	Parallel development branch management
`finishing-a-development-branch`	Merge/PR decision workflow with cleanup
`subagent-driven-development`	Fast iteration with two-stage review

Meta Skills

Skill	Purpose
`writing-skills`	Guidelines for creating new skills with testing methodology
`using-superpowers`	Introduction to the skills system

Daily Workflow Examples

Example 1: Starting a New Feature

User: I want to add user authentication with OAuth2

Claude (with Superpowers):
1. [brainstorming activates] Let me understand your requirements...
   - What OAuth providers do you need?
   - Session or JWT tokens?
   - Required permission scopes?

2. [After discussion] Here's the design spec. [Saves to file]

3. [writing-plans activates] Here's the implementation plan:
   - Task 1: Set up OAuth configuration (3 min)
   - Task 2: Write auth callback tests (5 min)
   - Task 3: Implement callback handler (5 min)
   ...

4. [subagent-driven-development] Executing tasks autonomously with reviews...

5. [finishing-a-development-branch] All tests passing. Merge or create PR?

Example 2: Debugging a Complex Issue

User: Users are getting logged out randomly

Claude (with Superpowers):
[systematic-debugging activates]

Phase 1: Root Cause Tracing
- Analyzing session management code...
- Checking token expiration logic...
- Found: Token refresh race condition

Phase 2: Defense in Depth
- Multiple potential fixes identified
- Recommended: Add token refresh mutex

Phase 3: Implementation with TDD
[test-driven-development activates]
- Writing failing test for race condition
- Implementing fix
- Verifying test passes

Phase 4: Verification
[verification-before-completion activates]
- Running full test suite
- Simulating concurrent requests
- Confirmed: Issue resolved

Key Features That Set Superpowers Apart

Automatic Skill Activation

Skills trigger automatically based on context—no manual commands needed. The agent checks for relevant skills before any task, making these mandatory workflows, not suggestions.

Quality Gates Between Tasks

Code review happens between tasks, blocking progress on critical issues. This ensures problems are caught early rather than accumulating.

TDD Enforcement

The system actually deletes code written before tests exist. This enforces discipline that even experienced developers sometimes skip.

Structured Task Breakdown

Implementation plans include:

Exact file paths
Complete code snippets
Verification steps
Time estimates (2-5 minutes per task)

Comparison with Similar Tools

Feature	Superpowers	Generic Claude Code	Cursor + Rules
Automatic workflow activation	Yes	No	Partial
TDD enforcement	Yes (deletes pre-test code)	No	No
Subagent orchestration	Yes	Limited	No
Git worktree management	Yes	Manual	No
Quality gates between tasks	Yes	No	No
Autonomous execution	Up to 2 hours	Per request	Per request

Precautions and Best Practices

Do’s

Trust the process - Let Superpowers guide you through design before coding
Provide context - The more you share during brainstorming, the better the implementation
Review checkpoints - Use human checkpoints to validate direction
Update regularly - Run /plugin update superpowers for latest skills

Don’ts

Don’t skip brainstorming - Rushing to code defeats the purpose
Don’t ignore test failures - Fix before continuing
Don’t bypass quality gates - They exist for good reasons
Don’t forget to verify - Ensure fixes actually work

Troubleshooting FAQ

Q: Skills aren’t activating automatically? A: Run /help to verify installation. If skills don’t appear, try reinstalling.

Q: Can I create custom skills? A: Yes! Use the writing-skills skill as a guide. Skills live in the repository for direct contribution via PRs.

Q: How do I skip a workflow step? A: You can override, but it’s not recommended. The system is designed as a complete workflow.

Q: Does it work with non-TypeScript projects? A: Yes, the skills are language-agnostic. The principles apply to any codebase.

Contributing to Superpowers

Fork the repository
Create a branch for your skill
Follow the writing-skills guidelines
Submit a PR

The complete guide is in skills/writing-skills/SKILL.md.

Resources and References

GitHub Repository: obra/superpowers
Marketplace: obra/superpowers-marketplace
Issues: Report bugs or request features
License: MIT

Conclusion

Superpowers represents a paradigm shift from “AI writes code” to “AI follows engineering discipline.” By making structured workflows mandatory rather than optional, it produces higher-quality code through autonomous but systematic development processes.

If you’ve been frustrated by AI assistants that generate code without proper testing or design consideration, Superpowers is your solution. Install it today and transform Claude Code into the disciplined engineering partner you deserve.

Ready to level up your Claude Code experience?

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Your future self (and your test suite) will thank you.

🎚️ CodexBar: macOS Menu Bar Usage Stats for Claude Code & OpenAI Codex

Dec 25, 2025

Vibe Sparking

CodexBar is a tiny macOS 15+ menu bar app created by Peter Steinberger (@steipete) that keeps your AI coding assistant usage limits always visible. Monitor both OpenAI Codex and Claude Code limits - including 5-hour session windows and weekly caps - without logging into any dashboard.

Dual provider support: Track both Codex (5h/weekly + credits) and Claude Code (session/weekly + Sonnet-only limits) simultaneously
Zero login required: Reads directly from local CLI output - no passwords, no browser sessions needed
Real-time visibility: See remaining tokens, reset timers, and account info from your menu bar

🧩 Why You Need Usage Monitoring

If you’re actively using Claude Code or OpenAI Codex for development, you’ve likely hit rate limits unexpectedly. Here’s why CodexBar is essential:

Avoid workflow interruptions Know your remaining quota before starting a major coding session. No more “rate limited” surprises in the middle of complex refactoring.
Track multiple time windows Both services use overlapping 5-hour and weekly windows. CodexBar visualizes both so you understand exactly when limits reset.
Monitor Sonnet-only limits (Claude) Claude Code’s Sonnet model has its own weekly cap. CodexBar shows this separately so you can strategically choose when to use which model.
Credits visibility (Codex) See your paid credits balance alongside rate limits. Know when you’re burning through free tier vs. paid usage.

⚙️ Installation

Homebrew (Recommended)

brew install --cask steipete/tap/codexbar

Update via:

brew upgrade --cask steipete/tap/codexbar

Manual Download

Download the ready-to-run zip from GitHub Releases.

🔧 Requirements

macOS 15+ (Sequoia or later)
For Codex: Codex CLI ≥ 0.55.0 installed and logged in
For Claude Code: Claude CLI installed via claude --version and logged in via claude login

CodexBar auto-detects installed CLIs on first launch:

Codex enabled by default
Claude turns on automatically when claude binary is present

🚀 How It Works

Reading Claude Code Usage

CodexBar runs claude /usage and claude /status in a local PTY (pseudo-terminal) to extract:

Session usage percentage
Weekly usage percentage
Sonnet-only weekly limit
Reset countdown timers
Account email, organization, and login method

Privacy note: Everything stays local. No network calls beyond what the Claude CLI itself makes.

Reading Codex Usage

CodexBar prefers the Codex app-server RPC for rate limits and credits. Falls back to PTY scrape of codex /status if RPC unavailable.

Optional “Access OpenAI via web” setting adds:

Code review remaining
Usage breakdown
Credits usage history

This reuses existing signed-in chatgpt.com session via Safari/Chrome cookie import - no passwords stored.

📊 Visual Status Indicators

The menu bar icon uses a clever two-bar system:

Bar	What It Shows
Top bar	5-hour window quota (or credits bar if weekly exhausted)
Bottom bar	Weekly window quota (thin line)

Icon variants:

Codex mode: Features the signature “eyelid blink” design
Claude mode: Shows Claude’s notch/leg variant
Errors/unknowns: Icon dims (no confusing text)

⚡ Refresh Options

Menu → “Refresh every…” offers these presets:

Manual only
1 minute
2 minutes
5 minutes (default)
15 minutes

Manual mode still allows on-demand “Refresh now” from the menu.

🛡️ Privacy & Security

CodexBar is designed with privacy in mind:

No disk scanning - See issue #12 for audit notes
Per-provider data isolation - Claude info never mixes with Codex info
Local CLI reading only - Account details come directly from CLI output
No password storage - Optional web access uses existing browser cookies

CodexBar is part of a suite of developer productivity tools from steipete:

Tool	Description
Trimmy	Flatten multi-line shell snippets for paste-and-run
MCPorter	TypeScript toolkit + CLI for MCP servers

Inspiration: ccusage - CLI tool for Claude Code usage cost tracking (which we’ve covered previously).

📝 Known Limitations

Scenario	Behavior
No Codex usage yet	Shows “No usage yet” - run one prompt and refresh
Claude CLI missing	Shows “Claude CLI is not installed”
Not logged in	Shows respective login error
Reset time parsing fails	Surfaces raw text when timezone info missing

✍️ Summary

CodexBar solves a real pain point for heavy AI coding assistant users:

✅ See both Codex and Claude Code limits at a glance
✅ Monitor 5-hour sessions AND weekly windows
✅ Track Sonnet-specific limits and paid credits
✅ Zero login required - reads local CLI data
✅ Privacy-first design with no disk scanning

Install it via brew install --cask steipete/tap/codexbar and never be surprised by rate limits again.

📌 Want more Claude Code tips, usage optimization strategies, and AI developer tools? Follow our channel for the latest guides on maximizing your AI-assisted development workflow!

Boris Cherny: How the Creator of Claude Code Grew His Career from Meta to Anthropic

Dec 25, 2025

Vibe Sparking

Introduction

Behind every revolutionary product is a story of personal growth, strategic thinking, and relentless curiosity. Boris Cherny, the creator of Claude Code at Anthropic, exemplifies this truth. His journey from startups to venture capital, through a decade at Meta (Facebook/Instagram), to leading one of the most impactful AI developer tools demonstrates key principles that any engineer can apply.

This article distills Boris’s career insights, revealing how he went from a mid-level engineer to principal at Meta, and finally to creating Claude Code—a tool that now writes 80-90% of its own codebase.

Boris Cherny Career Growth

The Unconventional Path

Boris started his first startup at 18, worked at a hedge fund, and notably has no CS degree—he studied economics before dropping out to pursue startups. His trajectory proves that programming is a practical skill learned on the job, not in classrooms.

Key milestones at Meta (2012-2022):

IC4 (Mid-level): Joined “under-leveled” working on Messenger-Groups integration
IC5-IC6: Led Groups web migration; created the Undux state management library
IC7 (Senior Staff): Drove Public Groups feature with complex data model migrations
IC8 (Principal): Scoped work for hundreds of engineers; led Instagram’s Python-to-Hack migration

Five Principles for Career Growth

1. Design for the Model Six Months from Now

In the fast-evolving AI landscape, don’t build for current model capabilities—design for future ones.

“Don’t build for today’s model, build for the model six months from now.” — Ben Mann, Boris’s manager at Anthropic

This forward-thinking approach explains why Claude Code initially felt underwhelming but became transformative after Claude 4 series launched. Early products may have mediocre experiences, but when new models drop, you achieve quantum leaps.

2. Discover Latent Demand

The most successful products don’t invent new behaviors—they satisfy hidden, existing ones.

Boris observed at Facebook that users were “abusing” Groups for commerce 40% of the time. This observation birthed Facebook Marketplace. Similarly, Dating emerged from observing how people were already using the platform for connections.

Lesson: Watch what users are hacking together with your existing features—that’s where product-market fit hides.

3. Side Projects Are Your Biggest Career Lever

Through solving repeated pain points and promoting solutions as company-wide tools, Boris accumulated cross-team influence rapidly.

His “20% time” projects included:

Undux: A state management library for React
TypeScript Book & Meetup: Community building in the developer space
Lint Rule Automation: Turning repeated code review comments into automated checks
Large Dataset Testing Framework: Infrastructure benefiting thousands of engineers

“Better engineering is the easiest way to grow your network and gain influence as an engineer.”

4. Become a Generalist Who Breaks Swim Lanes

High-impact engineers don’t just write code—they develop product sense, design ability, and user research skills.

At both Meta and Anthropic, there are no formal titles. Everyone is a “Member of Technical Staff” regardless of whether they’re an engineer, PM, or designer. This culture forces constant re-validation through execution rather than title.

“Just because you’re a product engineer doesn’t mean you can’t build infra.”

5. Common Sense Is Your Superpower

In complex organizations with historical baggage and process inertia, the most reliable decision-making framework is returning to basics:

What does the user actually need?
Does this make sense?

Rather than being led by organizational momentum, successful leaders constantly ask these fundamental questions.

The Claude Code Creation Story

Origin

Claude Code started as an accidental discovery during internal experiments at Anthropic. Boris’s manager pushed beyond autocomplete thinking, encouraging design for future model capabilities.

The Struggle

Initially, Boris only used Claude Code for about 10% of his work. The product wasn’t viable until Sonnet/Opus 4 launched in March 2024.

The Breakthrough

After model improvements, usage jumped to 50% of coding work. Today, 80-90% of Claude Code is written by Claude Code itself. Surprisingly, adoption spread beyond engineers to data scientists and sales teams—unexpected use cases the team hadn’t anticipated.

Hiring Philosophy: Look for “Side Quests”

Boris actively seeks engineers with curiosity beyond daily work:

“When I hire engineers, this is definitely something I look for… cool weekend projects, like someone who’s really into making kombucha.”

This signals growth mindset and intellectual curiosity—traits that separate good engineers from great ones.

Key Quotes for Your Career

On imposter syndrome:

“No one knows what they’re doing at any level. If you don’t feel it, you’re not pushing hard enough.”

On focus vs. breadth:

“Writing code anchors you to reality. Without it, you lose intuition quickly—dangerous place to be.”

On team dynamics:

“You never want to tell anyone what to do. Understand what they want, then present opportunity—it always works better.”

On organizational change:

“Just do it. Sometimes you need consensus, sometimes you act. Leaders juggle both constantly.”

Actionable Takeaways

Stop chasing titles—pursue interesting problems and impact. Promotions follow naturally.
Invest in side projects—even small automations that help your team compound into massive influence over time.
Become the generalist—learn product, design, and user research alongside engineering. The most valuable engineers are those who can wear multiple hats.
Apply common sense liberally—when lost in organizational complexity, ask “what does the user actually need?”
Build for the future—whether in AI or any fast-moving field, design for where technology will be, not where it is today.

Conclusion

Boris Cherny’s career offers a masterclass in engineering growth: start by solving your own problems, scale solutions to help others, earn trust through execution rather than titles, and always design for the future.

Claude Code exists because Boris spent a decade building products (many failed), learning what great developer experience feels like, and positioning himself at the intersection of code quality and AI capability.

For engineers seeking rapid career growth, his formula is clear: Be curious. Build side projects. Think in systems. Design for tomorrow.

References

Continuous Claude: The Ultimate Context Management System for Claude Code

Dec 25, 2025

Vibe Sparking

Continuous Claude: The Ultimate Context Management System for Claude Code

When working with Claude Code on complex projects, you’ve likely encountered the frustrating “context degradation” problem. After several compaction cycles, you’re essentially working with a summary of a summary of a summary. Signal degrades into noise, and Claude starts hallucinating context.

Continuous Claude solves this fundamental problem through a revolutionary approach: clear, don’t compact.

The Core Problem: Context Compaction Decay

Session Start: Full context, high signal
    ↓ work, work, work
Compaction 1: Some detail lost
    ↓ work, work, work
Compaction 2: Context getting murky
    ↓ work, work, work
Compaction 3: Now working with compressed noise
    ↓ Claude starts hallucinating context

Traditional approaches try to optimize compaction algorithms. Continuous Claude takes a fundamentally different path: preserve state externally, clear context completely, resume with full signal.

The Solution: Ledgers and Handoffs

Session Start: Fresh context + ledger loaded
    ↓ focused work
Complete task, save to ledger
    ↓ /clear
Fresh context + ledger loaded
    ↓ continue with full signal

Why This Works

Ledgers are lossless - You control exactly what’s saved
Fresh context = full signal - No degraded summaries
Agents spawn clean - Each agent gets isolated context windows

Key Features

1. Continuity System

Within-Session (Ledger)

Before running /clear:

"Update the ledger, I'm about to clear"

Creates/updates CONTINUITY_CLAUDE-<session>.md with:

Goal and constraints
What’s done, what’s next
Key decisions
Working files

Between-Sessions (Handoff)

When done for the day:

"Create a handoff, I'm done for today"

Creates detailed handoff with:

Complete context
Recent changes with file:line references
Learnings and patterns
Next steps

2. Hook System Architecture

Continuous Claude uses a sophisticated hook system that intercepts Claude Code lifecycle events:

Event	When	What It Does
SessionStart	New session, `/clear`, compact	Loads ledger + latest handoff into context
PreCompact	Before context compaction	Creates auto-handoff, blocks manual compact
UserPromptSubmit	Before processing user message	Shows skill suggestions, context warnings
PostToolUse	After Edit/Write/Bash	Tracks modified files for auto-summary
SubagentStop	Agent finishes	Logs agent completion
SessionEnd	Session closes	Cleanup temp files

3. MCP Code Execution Without Context Pollution

Tools are executed via scripts, not loaded into context. This saves significant tokens:

# Example: run a script
uv run python -m runtime.harness scripts/qlty_check.py --fix

4. Agent Orchestration

For complex implementations, the implement_plan orchestrator spawns task agents:

implement_plan (orchestrator)
    ├── task-agent (task 1) → handoff-01.md
    ├── task-agent (task 2) → handoff-02.md
    └── task-agent (task 3) → handoff-03.md

Each task agent:

Reads previous handoff
Does its work with TDD
Creates handoff for next agent
Returns summary to orchestrator

Quick Start

Option 1: Use in a Single Project

# Clone
git clone https://github.com/parcadei/Continuous-Claude.git
cd Continuous-Claude

# Install Python deps
uv sync

# Configure (optional - add API keys for extra features)
cp .env.example .env

# Start
claude

Option 2: Install Globally

# After cloning and syncing
./install-global.sh

Option 3: Initialize a New Project

cd your-project
~/.claude/scripts/init-project.sh

Natural Language Triggers

Continuous Claude responds to natural language. Say certain phrases and Claude activates the right skill or spawns an agent.

Session Management

Say This	What Happens
”save state”, “update ledger”, “before clear”	Updates continuity ledger
”done for today”, “wrap up”, “create handoff”	Creates detailed handoff doc
”resume work”, “continue from handoff”	Loads handoff, continues

Planning & Implementation

Say This	What Happens
”create plan”, “design”, “architect”	Spawns plan-agent
”validate plan”, “before implementing”	Spawns validate-agent
”implement plan”, “execute plan”	Spawns implement_plan

Code Quality

Say This	What Happens
”implement”, “add feature”, “fix bug”	TDD workflow activates
”lint”, “code quality”, “auto-fix”	Runs qlty-check
”commit”, “push”, “save changes”	Runs commit skill

StatusLine: Real-Time Context Indicator

The colored status bar shows context usage:

45.2K 23% | main U:3 | ✓ Fixed auth → Add tests

Color coding:

🟢 Green (< 60%): Normal
🟡 Yellow (60-79%): Warning - consider handoff soon
🔴 Red (≥ 80%): Critical - create handoff now

Skills vs Agents

Skills run in current context - quick, focused, minimal token overhead.

Agents spawn with fresh context - use for complex tasks that would degrade in compacted context.

When to Use Agents

Brownfield exploration → rp-explorer
Multi-step research → research-agent
Complex debugging → debug-agent
Implementation with handoffs → implement_plan

Optional Integrations

Braintrust Session Tracing

Track every session for learning from past work:

Session traces - Every turn, tool call, and LLM response logged
Automatic learnings - Extracts “What Worked/Failed/Patterns” at session end
Artifact Index integration - Handoffs linked to trace IDs

Compound Learnings

Transform session learnings into permanent rules:

"compound my learnings"
→ Analyzes .claude/cache/learnings/*.md
→ Identifies recurring patterns
→ Creates new rules in .claude/rules/

Directory Structure

.claude/
├── skills/          # Skill definitions (SKILL.md)
├── hooks/           # Session lifecycle (TypeScript)
├── agents/          # Agent configurations
├── rules/           # Behavioral rules
└── settings.json    # Hook registrations

scripts/             # MCP workflow scripts
thoughts/            # Research, plans, handoffs

Comparison: Traditional vs Continuous Claude

Aspect	Traditional Approach	Continuous Claude
Context Degradation	Cumulative loss	Zero loss
Session Continuity	Manual notes	Automated ledgers
Agent Context	Inherited degraded	Fresh isolated
Learning Loop	None	Compound learnings
Token Efficiency	Tools loaded in context	Scripts executed externally

Best Practices

Update ledger before /clear - Always save state first
Create handoffs at stopping points - Don’t wait until context is critical
Use agents for complex tasks - They get clean context
Leverage compound learnings - Turn patterns into rules
Watch the StatusLine - It shows when to create handoffs

Conclusion

Continuous Claude represents a paradigm shift in how we approach context management for AI coding assistants. By embracing “clear, don’t compact” and building robust state preservation through ledgers and handoffs, it enables:

Lossless context preservation across sessions
Token-efficient MCP execution without context pollution
Intelligent agent orchestration with isolated context windows
Continuous learning that improves over time

For teams working on complex, long-running projects with Claude Code, Continuous Claude is an essential addition to your development toolkit.

References

Personal AI Infrastructure (PAI): Build Your Own AI-Powered Operating System

Dec 24, 2025

Vibe Sparking

Personal AI Infrastructure (PAI): Build Your Own AI-Powered Operating System

Introduction

Right now, the most powerful AI setups are being built inside companies for efficiency and profits. But what if you could have the same sophisticated AI infrastructure available to everyone? That’s exactly what Personal AI Infrastructure (PAI) delivers.

Created by security researcher and AI pioneer Daniel Miessler, PAI is an open-source template for building your own AI-powered operating system. It’s the foundation for creating a Personal AI System that understands your larger goals and context, gets better over time, and works for you because it’s yours.

What is PAI?

PAI (Personal AI Infrastructure) is open-source scaffolding built on Claude Code, designed to be platform-independent. The architecture, skills, and workflows are structured so future migrations to other AI platforms remain straightforward.

Core Philosophy

“The best AI in the world should be available to everyone.”

The purpose of technology is to serve humans—not the other way around. PAI enables regular people to use AI to help them flourish, not just tech workers inside corporations.

Core Components

1. Skills System

Skills are self-contained AI capabilities with routing, workflows, and documentation. Each skill follows the “skills-as-containers” pattern:

Component	Description
Skills	Domain expertise encoded as reusable modules (security analysis, content creation, research workflows)
Agents	Specialized AI personalities for different tasks (engineer, researcher, designer)
Hooks	Event-driven automation that captures work and manages state
History	Automatic documentation system (UOCS) that captures everything

2. File-System-Based Context

Instead of cramming everything into massive prompts, PAI organizes knowledge into a hierarchical structure:

Projects: Active work with context
Methodologies: How you approach problems
Philosophy: Your principles and values
Tools: Technical capabilities
Tasks: Specific actions and workflows

Each directory contains specialized knowledge loaded only when needed.

3. Native Fabric Patterns

PAI includes native integration with Fabric patterns—248+ AI patterns for content analysis and generation:

extract_wisdom: Extract key insights from content
summarize: Create concise summaries
threat_modeling: Security analysis workflows
And 245+ more patterns

Patterns run directly in Claude’s context using your subscription’s model, with full conversation history access.

The Thirteen Founding Principles

PAI is built on 13 foundational principles:

Clear Thinking + Prompting is King - Quality outcomes depend on quality thinking
Scaffolding > Model - System architecture matters more than AI model power
As Deterministic as Possible - Same input → Same output
Code Before Prompts - Write code to solve problems, prompts to orchestrate
Spec / Test / Evals First - Define expected behavior before implementation
UNIX Philosophy - Do one thing well, compose tools through standard interfaces
ENG / SRE Principles - Apply software engineering rigor to AI systems
CLI as Interface - Every operation accessible via command line
Goal → Code → CLI → Prompts → Agents - Proper development pipeline
Meta / Self Update System - Systems that improve themselves
Custom Skill Management - Skills as organizational units
Custom History System - Automatic capture of valuable work
Custom Agent Personalities - Specialized agents for different tasks

Quick Start Installation

macOS Setup

# 1. Clone PAI
git clone https://github.com/danielmiessler/PAI.git ~/PAI

# 2. Create Symlink
[ -d ~/.claude ] && mv ~/.claude ~/.claude.backup
ln -s ~/PAI/.claude ~/.claude

# 3. Run Setup Wizard
~/.claude/Tools/setup/bootstrap.sh

# 4. Configure API Keys
cp ~/.claude/.env.example ~/.claude/.env
nano ~/.claude/.env

# 5. Start Claude Code
source ~/.zshrc
claude

Linux Setup

# Same steps as macOS, but source ~/.bashrc instead
source ~/.bashrc
claude

Windows Setup (PowerShell as Admin)

# Clone and create symlink
git clone https://github.com/danielmiessler/PAI.git $env:USERPROFILE\PAI
New-Item -ItemType SymbolicLink -Path "$env:USERPROFILE\.claude" -Target "$env:USERPROFILE\PAI\.claude"

# Run setup and configure
& "$env:USERPROFILE\.claude\tools\setup\bootstrap.ps1"
Copy-Item "$env:USERPROFILE\.claude\.env.example" "$env:USERPROFILE\.claude\.env"

Best Practices

1. Start Clean, Small, and Simple

Build the scaffolding that makes AI reliable before adding complexity. Following Miessler’s “solve once, reuse forever” philosophy, each component becomes reusable.

2. Encode Your Domain Expertise

Every time you solve a problem, turn it into a reusable component:

Commands for specific workflows (write-blog-post, analyze-security)
Fabric patterns for content analysis and generation
Skills for domain expertise

3. Let History Compound

The History System solves context loss between sessions. Everything gets automatically documented:

Work artifacts and decisions
Patterns and approaches used
Lessons learned

4. Customize Your Agent Identity

PAI is fully platform-agnostic—your AI identity, your system:

Configure your DA (Digital Assistant) name
Set your preferences and principles
Define your working style

Use Cases

Security Research

Threat modeling with domain context
Vulnerability analysis workflows
Security report generation

Content Creation

Blog post writing with your voice
Research synthesis and summaries
Documentation generation

Development Workflows

Code review with your standards
Architecture decision documentation
Project scaffolding

Personal Knowledge Management

Research capture and organization
Learning documentation
Decision journaling

Technology Stack

Category	Choice
Runtime	Bun (NOT Node.js)
Language	TypeScript (NOT Python)
Package Manager	Bun
Format	Markdown
Testing	Vitest
Voice	ElevenLabs TTS

What’s New in v0.9.x

Observability Dashboard: Real-time agent monitoring with live charts
Genericized Identity: Configure your DA name across the entire system
Platform-Agnostic Configuration: Clear separation of identity/paths and API keys
Native Fabric Patterns: 248 patterns run directly in Claude’s context

FAQ

Q: Is PAI just for developers?

No! PAI is designed to give regular people access to sophisticated AI infrastructure. While technical knowledge helps, the goal is human flourishing, not just developer productivity.

Q: Can I use PAI with models other than Claude?

Yes. While currently built on Claude Code, PAI’s architecture is platform-independent. The skills, workflows, and patterns can migrate to other AI platforms.

Q: How does PAI differ from just using Claude Code?

PAI adds structure, history, skills, and patterns on top of Claude Code. It’s not a different AI—it’s a framework that makes Claude Code work specifically for you.

Q: Is PAI free?

Yes, PAI is open-source under MIT license. You’ll need a Claude subscription for the underlying AI capabilities.

Comparison with Similar Tools

Feature	PAI	Plain Claude Code	Custom GPTs
Skills System	✅ 65+ skills	❌	Limited
History Persistence	✅ Automatic	❌	❌
Native Fabric	✅ 248 patterns	❌	❌
Self-Updating	✅	❌	❌
Open Source	✅ MIT	N/A	❌
Platform Agnostic	✅	❌	❌

References

PAI GitHub Repository
PAI Walkthrough Video
The Real Internet of Things - The vision behind PAI
Building a Personal AI Infrastructure - Daniel’s blog post
Fabric Framework - AI patterns library

Summary

Personal AI Infrastructure represents a paradigm shift in how we think about AI assistance. Instead of relying on generic chatbots or corporate AI systems, PAI empowers individuals to build AI infrastructure that:

Knows your context: Your goals, preferences, and working style
Learns over time: History compounds, patterns emerge
Serves your interests: Not engagement metrics or corporate profits
Remains yours: Open-source, portable, and customizable

As Daniel Miessler points out, the real power of AI infrastructure lies not in model intelligence but in orchestration. The magic happens when you create a system that knows you, adapts to your needs, and works autonomously on your behalf.

Start clean. Start small. Build the AI infrastructure you need.

OpenSkills: Universal Skills Loader for AI Coding Agents

Dec 24, 2025

Vibe Sparking

OpenSkills: Universal Skills Loader for AI Coding Agents

AI coding agents have revolutionized software development, but each agent operates in its own ecosystem with unique capabilities. OpenSkills bridges this gap by bringing Anthropic’s powerful skills system to all AI coding agents.

What is OpenSkills?

OpenSkills is a universal skills loader that implements Anthropic’s Agent Skills specification for any AI coding agent. It brings Claude Code’s skills system to Cursor, Windsurf, Aider, and other agents with 100% compatibility.

npm i -g openskills
openskills install anthropics/skills
openskills sync

Why OpenSkills Matters

The Problem

Each AI coding agent has its own way of handling specialized capabilities:

Claude Code has a built-in skills system with marketplace
Cursor uses custom rules and instructions
Windsurf has its own knowledge management
Aider relies on conventions and prompts

This fragmentation means skills and workflows don’t transfer between agents.

The Solution

OpenSkills provides a unified skills format that works across all agents:

Same prompt format - <available_skills> XML structure
Same marketplace - Access Anthropic’s official skills
Same folder structure - Uses .claude/skills/ by default
Same SKILL.md format - YAML frontmatter + markdown instructions
Progressive disclosure - Load skills on demand, not upfront

Key Features

1. Universal Compatibility

OpenSkills works with any AI coding agent by using CLI commands instead of proprietary tool calls:

Aspect	Claude Code	OpenSkills
Invocation	`Skill("pdf")`	`openskills read pdf`
Prompt Format	`<available_skills>` XML	Identical
Folder Structure	`.claude/skills/`	Identical
SKILL.md Format	YAML + markdown	Identical

2. Multiple Installation Sources

Install skills from various sources:

# Anthropic's official marketplace
openskills install anthropics/skills

# Any GitHub repository
openskills install your-org/custom-skills

# Local paths
openskills install ./local-skills/my-skill

# Private git repos
openskills install git@github.com:your-org/private-skills.git

3. Progressive Disclosure

Skills load only when needed, keeping your agent’s context clean and focused. When the agent needs a skill:

Agent scans <available_skills> in AGENTS.md
Agent executes openskills read <skill-name>
Full skill instructions load into context
Agent follows instructions to complete task

4. Bundled Resources Support

Skills can include supporting resources:

my-skill/
├── SKILL.md           # Main instructions
├── references/
│   └── api-docs.md    # Supporting documentation
├── scripts/
│   └── process.py     # Helper scripts
└── assets/
    └── template.json  # Templates, configs

Quick Start Guide

Step 1: Install OpenSkills

npm i -g openskills

Requires Node.js 20.6+ and Git.

Step 2: Install Skills

# Interactive selection from marketplace
openskills install anthropics/skills

# Install all skills non-interactively
openskills install anthropics/skills -y

Available skills from Anthropic’s marketplace:

pdf - PDF manipulation (extract, merge, split, forms)
xlsx - Spreadsheet creation and analysis
docx - Document creation with tracked changes
pptx - Presentation creation and editing
canvas-design - Create posters and visual designs
mcp-builder - Build Model Context Protocol servers
skill-creator - Guide for authoring skills

Step 3: Sync to AGENTS.md

openskills sync

This updates your AGENTS.md file with the <available_skills> section:

<skills_system priority="1">
<available_skills>
<skill>
<name>pdf</name>
<description>Comprehensive PDF manipulation toolkit...</description>
<location>project</location>
</skill>
</available_skills>
</skills_system>

Advanced Usage

Global vs Project Installation

# Project-local (default, gitignored)
openskills install anthropics/skills

# Global (shared across all projects)
openskills install anthropics/skills --global

Universal Mode for Multi-Agent Setups

If you use Claude Code alongside other agents:

openskills install anthropics/skills --universal

This installs to .agent/skills/ to avoid conflicts with Claude Code’s native marketplace.

Priority order:

./.agent/skills/ (project universal)
~/.agent/skills/ (global universal)
./.claude/skills/ (project)
~/.claude/skills/ (global)

Local Development with Symlinks

For active skill development:

# Clone your skills repo
git clone git@github.com:your-org/my-skills.git ~/dev/my-skills

# Symlink into project
mkdir -p .claude/skills
ln -s ~/dev/my-skills/my-skill .claude/skills/my-skill

# Changes reflect immediately
openskills sync

Creating Custom Skills

Minimal Structure

---
name: my-skill
description: What this does and when to use it
---

# Instructions

When the user asks you to X, do Y...

Full Structure with Resources

my-skill/
├── SKILL.md
├── references/       # Supporting docs
├── scripts/          # Helper scripts
└── assets/           # Templates, configs

Publishing

Create a GitHub repository with your skill
Users install with: openskills install username/repo-name

Use Cases

1. Standardize Skills Across Teams

Use OpenSkills to share skills across your organization regardless of which AI agent team members prefer:

# Team repository with shared skills
openskills install your-org/team-skills

2. Extend Claude Code’s Marketplace

Install skills from any GitHub repository, not just Anthropic’s marketplace:

openskills install community-user/useful-skills

3. Private Enterprise Skills

Keep proprietary skills in private repositories:

openskills install git@github.com:enterprise/internal-skills.git

4. Multi-Agent Workflows

Use the same skills whether you’re in Claude Code, Cursor, or Windsurf:

# Works everywhere
openskills read pdf

Why CLI Instead of MCP?

OpenSkills uses CLI commands rather than MCP (Model Context Protocol) because:

Skills are static instructions - Not dynamic tools requiring server connections
No server needed - Skills are just markdown files
Universal compatibility - CLI works with any agent
Follows Anthropic’s design - Skills were designed as SKILL.md files
Simpler for users - No server management required

MCP and skills solve different problems. OpenSkills implements the skills spec as designed.

Best Practices

1. Keep Skills Focused

Each skill should handle one specific domain. Don’t create “do everything” skills.

2. Write Clear Descriptions

The description helps agents decide when to load the skill:

description: Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms

3. Use Progressive Disclosure

Put detailed instructions in SKILL.md, not the description. This keeps the <available_skills> section compact.

4. Include Examples

Help agents understand how to use your skill with concrete examples in the instructions.

Comparison with Alternatives

Feature	OpenSkills	Custom Prompts	MCP
Universal	Yes	Per-agent	Requires support
Progressive Loading	Yes	No	Yes
Marketplace Access	Yes	No	Different
Setup Complexity	Low	Varies	Higher
Bundled Resources	Yes	Limited	Yes

Conclusion

OpenSkills democratizes AI agent skills by making Anthropic’s well-designed skills system available to all agents. Whether you’re using Claude Code, Cursor, Windsurf, or Aider, you can now benefit from:

Standardized skills format across agents
Access to Anthropic’s marketplace via GitHub
Progressive disclosure for clean contexts
Easy skill sharing within teams and communities

Get started today:

npm i -g openskills
openskills install anthropics/skills
openskills sync

References

SkillsMP: The Open Marketplace for AI Agent Skills

Dec 24, 2025

Vibe Sparking

SkillsMP: The Open Marketplace for AI Agent Skills

AI coding assistants have become indispensable tools for developers, but their capabilities are often limited to what comes built-in. SkillsMP changes this by providing an open marketplace where developers can discover, install, and share skills across multiple AI platforms.

What is SkillsMP?

SkillsMP is an open-source marketplace hosting over 31,000 agent skills that work seamlessly with the most popular AI coding assistants:

Claude Code - Anthropic’s official CLI tool
Codex CLI - OpenAI’s command-line interface
ChatGPT - The world’s most popular AI assistant

All skills use the unified SKILL.md format, ensuring compatibility across platforms and making it easy to share capabilities between different AI tools.

The SKILL.md Standard

The SKILL.md format is the foundation of the agent skills ecosystem. It defines modular capabilities through:

Instructions - Clear guidance for the AI on what the skill does and how to use it
Scripts (optional) - Supporting code that extends functionality
Templates (optional) - Pre-built structures for common outputs

Key Characteristics

Skills are model-invoked, not user-invoked. This means the AI assistant decides when to activate a skill based on the context of your request, rather than requiring explicit commands.

---
name: my-skill
description: What this skill does and when to use it
---

# Instructions

When the user asks for X, follow these steps...

Installation Paths

Different AI tools have their own skill directories:

Tool	Personal Skills	Project Skills
Claude Code	`~/.claude/skills/`	`.claude/skills/`
Codex CLI	`~/.codex/skills/`	`.codex/skills/`
ChatGPT	Via plugin system	Via plugin system

Skill Categories

SkillsMP organizes its vast library into 13 categories:

Tools - General productivity enhancers
Development - Code generation and refactoring
Data & AI - Data analysis and ML utilities
Business - Business process automation
DevOps - Infrastructure and deployment
Testing & Security - QA and security scanning
Documentation - Docs generation and maintenance
Content & Media - Content creation tools
Lifestyle - Personal productivity
Research - Information gathering
Databases - Database operations
Blockchain - Web3 and crypto tools

Quality Standards

SkillsMP maintains quality through:

Minimum 2-star filter - Only GitHub repos with community validation
Open-source requirement - All skills are publicly auditable
User review recommended - Always review code before installation

Using SkillsMP

Browsing Skills

Visit skillsmp.com to browse the marketplace. You can:

Search by keyword
Filter by category
Sort by popularity or recency
View skill documentation

Installing Skills

For Claude Code, installation is straightforward:

# Install a skill from the marketplace
curl -O https://skillsmp.com/skills/skill-name/SKILL.md
mv SKILL.md ~/.claude/skills/skill-name/

Many skills also support one-command installation via their marketplace.json configuration.

Multiple Skill Execution

Claude Code supports running multiple skills simultaneously. The AI intelligently selects which skills to activate based on context, enabling complex workflows that combine several capabilities.

Creating Custom Skills

Want to contribute to the marketplace? Creating a skill requires just a SKILL.md file:

---
name: my-custom-skill
description: A brief description of what this skill does
author: your-github-username
version: 1.0.0
---

# My Custom Skill

## When to Use

Use this skill when the user requests...

## Instructions

1. First, do this...
2. Then, do that...
3. Finally, complete with...

## Examples

### Example 1
User: "Help me with X"
Response: [How to handle this request]

Publishing to Marketplace

Create a GitHub repository with your skill
Add a marketplace.json for easy installation
Submit to SkillsMP for indexing

Independence and Official Resources

Important: SkillsMP is an independent community project. It is not affiliated with Anthropic or OpenAI.

For official skill resources:

Anthropic’s Official Skills: github.com/anthropics/skills
OpenAI’s Documentation: platform.openai.com

Best Practices

For Users

Review before installing - Always check the source code
Start with popular skills - Higher stars indicate community trust
Keep skills updated - Check for updates regularly
Report issues - Help improve the ecosystem

For Skill Creators

Write clear descriptions - Help users understand when to use your skill
Include examples - Show concrete use cases
Document thoroughly - Explain all features and limitations
Test across platforms - Ensure compatibility

The Future of AI Agent Skills

The standardization around SKILL.md represents a significant shift in how we extend AI capabilities. As more developers create and share skills:

Specialization increases - Skills become more focused and powerful
Quality improves - Community curation drives excellence
Adoption grows - Easy installation removes barriers
Innovation accelerates - Building on others’ work speeds development

Conclusion

SkillsMP democratizes access to AI agent capabilities by providing:

31,000+ ready-to-use skills across 13 categories
Cross-platform compatibility via the SKILL.md standard
Open-source transparency with community quality control
Easy installation for all major AI coding assistants

Whether you’re looking to enhance your AI coding workflow or contribute your own skills to the community, SkillsMP provides the platform to make it happen.

References

Agent Skills for Context Engineering: Build Production-Grade AI Agent Systems

Dec 24, 2025

Vibe Sparking

Agent Skills for Context Engineering: Build Production-Grade AI Agent Systems

In the rapidly evolving landscape of AI development, context engineering has emerged as one of the most critical disciplines for building effective agent systems. Unlike prompt engineering, which focuses on crafting effective instructions, context engineering addresses the holistic curation of all information entering a model’s limited attention window.

Agent Skills for Context Engineering by Murat Can Koylan is a comprehensive, open-source collection designed to teach the art and science of curating context to maximize agent effectiveness across any platform.

What is Context Engineering?

Context engineering is the discipline of managing the language model’s context window. The fundamental challenge is that context windows are constrained not by raw token capacity but by attention mechanics.

The Core Problem

As context length increases, models exhibit predictable degradation patterns:

Lost-in-the-Middle Phenomenon - Information in the middle of long contexts gets less attention
U-Shaped Attention Curves - Models focus more on beginning and end of context
Attention Scarcity - Limited “attention budget” must be allocated wisely

The Solution

Effective context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of desired outcomes. This requires understanding what context is, how it degrades, and how to optimize it.

Skills Overview

The collection is organized into three tiers of increasing complexity.

Foundational Skills

These skills establish the foundational understanding required for all subsequent context engineering work.

Skill	Description
context-fundamentals	Understand what context is, why it matters, and the anatomy of context in agent systems
context-degradation	Recognize patterns of context failure: lost-in-middle, poisoning, distraction, and clash
context-compression	Design and evaluate compression strategies for long-running sessions

Architectural Skills

These skills cover the patterns and structures for building effective agent systems.

Skill	Description
multi-agent-patterns	Master orchestrator, peer-to-peer, and hierarchical multi-agent architectures
memory-systems	Design short-term, long-term, and graph-based memory architectures
tool-design	Build tools that agents can use effectively

Operational Skills

These skills address the ongoing operation and optimization of agent systems.

Skill	Description
context-optimization	Apply compaction, masking, and caching strategies
evaluation	Build evaluation frameworks for agent systems

Key Concepts Deep Dive

1. Context Fundamentals

Understanding the anatomy of context in agent systems is essential:

Components of Context:

System prompts
Tool definitions
Retrieved documents
Message history
Tool outputs

Each component competes for limited attention. Effective agents prioritize high-signal information and compress or eliminate low-signal content.

2. Context Degradation Patterns

Recognizing failure patterns helps prevent them:

Lost-in-Middle: Critical information placed in the middle of long contexts receives less model attention.

Context Poisoning: Bad or conflicting information corrupts the model’s understanding.

Context Distraction: Irrelevant information diverts attention from important content.

Context Clash: Contradictory instructions or data create confusion.

3. Multi-Agent Patterns

Three primary architectures for multi-agent systems:

Orchestrator Pattern: A central agent coordinates specialized sub-agents, managing task delegation and result aggregation.

     [Orchestrator]
         /|\
        / | \
       /  |  \
   [Agent][Agent][Agent]

Peer-to-Peer Pattern: Agents communicate directly without central coordination, suitable for collaborative tasks.

Hierarchical Pattern: Layered agent structures where higher-level agents manage groups of lower-level agents.

4. Memory Systems

Effective agents require multiple memory types:

Short-term Memory:

Recent conversation context
Current task state
Immediate working memory

Long-term Memory:

Persistent knowledge stores
User preferences
Historical patterns

Graph-based Memory:

Relationship maps between concepts
Entity connections
Semantic networks

Installation and Usage

For Claude Code

Install skills by referencing the repository or copying skill folders into your configured skills directory:

# Clone the repository
git clone https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering.git

# Copy skills to your project
cp -r Agent-Skills-for-Context-Engineering/skills/* ./skills/

When working on context engineering tasks, activate relevant skills to load their instructions.

For Cursor

Copy skill content into .cursorrules or create project-specific rules files:

# Create rules file
cat skills/context-fundamentals/SKILL.md >> .cursorrules

The skills provide the context and guidelines that Cursor’s agent needs for effective context engineering.

For Custom Implementations

Extract the principles and patterns from any skill and implement them in your agent framework. The skills are deliberately platform-agnostic, making them applicable to any LLM-based system.

Recommended Use Scenarios

1. Building Production Agent Systems

When developing agents for real-world deployment:

Start with fundamentals - Understand context anatomy before optimization
Design memory early - Memory architecture affects all downstream decisions
Plan for degradation - Build in monitoring and recovery mechanisms
Test at scale - Evaluation frameworks catch issues before production

2. Optimizing Existing Agents

For teams with existing agent systems:

Diagnose context issues - Use degradation patterns to identify problems
Apply compression strategies - Reduce token usage without losing signal
Implement caching - Avoid redundant context loading
Add instrumentation - Build visibility into context usage

3. Multi-Agent Architecture Design

When building systems with multiple coordinating agents:

Choose the right pattern - Orchestrator vs peer-to-peer vs hierarchical
Design communication protocols - How agents share context
Manage shared memory - Coordination without conflicts
Handle failures gracefully - Recovery when agents fail

4. Educational and Training Purposes

For learning about agent development:

Progressive disclosure - Skills build on each other logically
Practical examples - Python pseudocode demonstrates concepts
Platform-agnostic - Learn principles, not vendor lock-in
Open source - Study, modify, and contribute

Daily Workflow Examples

Morning Context Review

1. Load context-fundamentals skill
2. Review overnight agent logs for degradation patterns
3. Identify context bottlenecks
4. Plan optimization tasks
5. Update monitoring dashboards

New Agent Development

1. Activate multi-agent-patterns skill
2. Design agent architecture diagram
3. Define context boundaries for each agent
4. Implement memory systems
5. Build evaluation framework
6. Test with context-degradation checks

Debugging Agent Issues

1. Load context-degradation skill
2. Identify symptoms (lost-in-middle? poisoning?)
3. Trace context flow through system
4. Apply appropriate fix strategy
5. Validate with evaluation skill

Best Practices

Design Philosophy

The collection follows three key principles:

1. Progressive Disclosure

Each skill is structured for efficient context use. At startup, agents load only skill names and descriptions. Full content loads only when a skill is activated for relevant tasks.

2. Platform Agnosticism

These skills focus on transferable principles rather than vendor-specific implementations. The patterns work across Claude Code, Cursor, and any agent platform that supports skills or allows custom instructions.

3. Conceptual Foundation with Practical Examples

Scripts and examples demonstrate concepts using Python pseudocode that works across environments without requiring specific dependency installations.

Skill Structure

Each skill follows the Agent Skills specification:

skill-name/
├── SKILL.md              # Required: instructions + metadata
├── scripts/              # Optional: executable code
└── references/           # Optional: additional docs

Contributing Guidelines

When contributing new skills:

Follow the skill template structure
Provide clear, actionable instructions
Include working examples where appropriate
Document trade-offs and potential issues
Keep SKILL.md under 500 lines for optimal performance

Comparison with Alternatives

Feature	Agent Skills	Custom Rules	Framework Docs
Platform Support	Any	Platform-specific	Framework-specific
Focus	Context engineering	General	Framework usage
Structure	Standardized	Variable	Variable
Progressive Loading	Yes	No	No
Open Source	MIT	Varies	Varies
Examples	Python pseudocode	Varies	Framework-specific

Why Agent Skills?

vs. Custom Rules:

Standardized structure enables sharing and reuse
Progressive disclosure reduces initial context cost
Community contributions expand coverage

vs. Framework Documentation:

Focuses on principles, not implementation details
Transferable across platforms
Practical orientation for production systems

Troubleshooting and FAQ

Common Questions

Q: Do these skills work with any LLM? A: Yes, the principles are LLM-agnostic. Examples use Python pseudocode that can be adapted to any environment.

Q: How do I know which skill to use? A: Start with fundamentals, then move to architectural skills for design decisions, and operational skills for optimization.

Q: Can I contribute new skills? A: Absolutely! Follow the template structure and submit pull requests. Community contributions are welcome.

Q: Are there costs associated with using these skills? A: No, the repository is MIT licensed. However, the LLMs you use with these skills may have associated costs.

Q: How do skills handle context limits? A: Progressive disclosure means only relevant content loads. Each skill is designed to stay under 500 lines.

Troubleshooting

Skills not loading:

Ensure skill folder structure is correct
Check that SKILL.md exists in skill directory
Verify file permissions

Poor agent performance:

Review context-degradation skill for diagnostic patterns
Check if context window is being exceeded
Evaluate information signal-to-noise ratio

Multi-agent coordination issues:

Review multi-agent-patterns skill
Check message passing protocols
Verify shared memory access patterns

Reference Links

GitHub Repository: muratcankoylan/Agent-Skills-for-Context-Engineering
Skill Template: Template folder in repository
Examples: X-to-Book System example
Agent Skills Specification: Follow repository for updates

Conclusion

Context engineering is becoming as fundamental to AI development as software engineering principles are to traditional development. Agent Skills for Context Engineering provides a structured, open, and platform-agnostic foundation for mastering this critical discipline.

Whether you’re building your first agent or optimizing production multi-agent systems, these skills offer the conceptual foundation and practical guidance needed for success. The progressive disclosure design means you can start small and expand as needed, while the platform-agnostic approach ensures your learning transfers across tools and frameworks.

The AI agent ecosystem is maturing rapidly, and context engineering will be a key differentiator between agents that work and agents that work well. Start with the fundamentals, understand degradation patterns, and build systems that manage context effectively.

Explore the full collection at Agent Skills for Context Engineering and join the community building better agent systems.

Enabling Claude Code to Work More Autonomously: Complete Guide to VS Code Extension, Checkpoints & Agent SDK

Dec 22, 2025

Vibe Sparking

Introduction

Anthropic has released several major upgrades to Claude Code that fundamentally transform how developers interact with AI-powered development tools. These updates include a native VS Code extension, version 2.0 of the terminal interface, and most notably, checkpoints for autonomous operation. Powered by Claude Sonnet 4.5, Claude Code now handles longer, more complex development tasks with unprecedented confidence and control.

This article provides a comprehensive guide to these new autonomy features, covering installation, configuration, best practices, and real-world workflow examples.

Key Features and Highlights

1. Native VS Code Extension (Beta)

The native VS Code extension brings Claude Code directly into your IDE with several powerful capabilities:

Real-time Change Visualization: See Claude’s changes in real-time through a dedicated sidebar panel with inline diffs
Graphical Experience: A richer, more visual Claude Code experience for developers who prefer IDEs over terminals
Seamless Integration: Works within your existing VS Code workflow without context switching

Installation: Download from the VS Code Extension Marketplace

2. Enhanced Terminal Experience (v2.0)

The refreshed terminal interface includes:

Improved Status Visibility: Better visual feedback on Claude’s current operations
Searchable Prompt History: Use Ctrl+r to search and reuse previous prompts
Streamlined UX: Easier navigation and command execution

3. Checkpoints System

The checkpoint system is a game-changer for autonomous development:

Automatic State Saving: Automatically saves your code state before each change
Instant Rewind: Tap Esc twice or use /rewind command to return to previous versions
Selective Restoration: Choose to restore code, conversation, or both
Multi-level Undo: Not just one level—checkpoints are kept for each change

Best Practice: Use checkpoints in combination with version control (git) for maximum safety.

4. Subagents for Parallel Development

Subagents delegate specialized tasks, enabling parallel development workflows:

# Example: Main agent spawns specialized subagents
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition

async for message in query(
    prompt="Build a full-stack feature with tests",
    options=ClaudeAgentOptions(
        allowed_tools=["Read", "Write", "Edit", "Bash", "Task"],
        agents={
            "backend-dev": AgentDefinition(
                description="Backend API developer",
                prompt="Build REST APIs following best practices",
                tools=["Read", "Write", "Edit", "Bash"]
            ),
            "frontend-dev": AgentDefinition(
                description="Frontend developer",
                prompt="Build React components with TypeScript",
                tools=["Read", "Write", "Edit", "Bash"]
            ),
            "test-engineer": AgentDefinition(
                description="Test automation engineer",
                prompt="Write comprehensive test coverage",
                tools=["Read", "Write", "Bash"]
            )
        }
    )
):
    print(message)

5. Hooks for Automated Workflows

Hooks trigger actions at specific points in the development lifecycle:

PostToolUse: Run tests after code changes
PreToolUse: Lint before commits
SessionStart/End: Initialize or cleanup resources
UserPromptSubmit: Validate or transform user input

# Example: Automatic test running after file edits
async def run_tests_after_edit(input_data, tool_use_id, context):
    file_path = input_data.get('tool_input', {}).get('file_path', '')
    if file_path.endswith('.py'):
        # Run pytest for Python files
        return {"command": "pytest", "args": [file_path]}
    return {}

options = ClaudeAgentOptions(
    hooks={
        "PostToolUse": [HookMatcher(matcher="Edit", hooks=[run_tests_after_edit])]
    }
)

6. Background Tasks

Keep long-running processes active without blocking progress:

Dev servers running continuously
Build watchers monitoring changes
Database migrations running in background
Compilation tasks executing asynchronously

Prerequisites and Installation

System Requirements

Node.js: Version 18 or higher
Python: Version 3.10 or higher (for Python SDK)
Operating System: macOS, Linux, or Windows with WSL

Installation Steps

1. Install Claude Code CLI

macOS/Linux/WSL:

curl -fsSL https://claude.ai/install.sh | bash

Homebrew (macOS):

brew install --cask claude-code

npm:

npm install -g @anthropic-ai/claude-code

2. Install the Agent SDK

TypeScript/Node.js:

npm install @anthropic-ai/claude-agent-sdk

Python:

pip install claude-agent-sdk

3. Configure API Key

export ANTHROPIC_API_KEY=your-api-key

Get your key from the Anthropic Console.

Alternative Providers:

Amazon Bedrock: CLAUDE_CODE_USE_BEDROCK=1
Google Vertex AI: CLAUDE_CODE_USE_VERTEX=1
Microsoft Foundry: CLAUDE_CODE_USE_FOUNDRY=1

Recommended Scenarios and Best Practices

Scenario 1: Complex Refactoring

When refactoring large codebases, checkpoints + subagents work together:

Create a checkpoint before starting
Spawn subagents for different modules
Each subagent refactors its assigned area
Hooks run tests after each change
If tests fail, rewind to checkpoint

Scenario 2: Feature Development with TDD

# Start Claude Code with test-driven development workflow
claude --with-hooks "run tests after each edit"

# Claude will:
# 1. Write failing tests first
# 2. Implement code to pass tests
# 3. Automatically run tests after each edit
# 4. Create checkpoints at each green state

Scenario 3: API Development Pipeline

# Full-stack API development with parallel agents
agents = {
    "api-designer": AgentDefinition(
        description="OpenAPI specification writer",
        prompt="Design RESTful APIs following OpenAPI 3.0",
        tools=["Read", "Write"]
    ),
    "api-implementer": AgentDefinition(
        description="Backend implementation",
        prompt="Implement FastAPI endpoints from spec",
        tools=["Read", "Write", "Edit", "Bash"]
    ),
    "api-tester": AgentDefinition(
        description="API test automation",
        prompt="Write pytest tests for all endpoints",
        tools=["Read", "Write", "Bash"]
    )
}

Daily Workflow Examples

Morning Code Review

# Review overnight PRs with Claude
claude "Review all open PRs, summarize changes, identify potential issues"

Debugging Session

# Use checkpoints for safe debugging
claude "Debug the auth module - create checkpoints before each change"

End-of-Day Cleanup

# Automated code cleanup with hooks
claude "Clean up TODO comments, format code, run linter" --auto-commit

Precautions and FAQ

Safety Considerations

Checkpoints vs Git: Checkpoints only track Claude’s edits, not user edits or bash commands. Always use git for version control.
Subagent Permissions: Be careful about which tools you grant to subagents. Use principle of least privilege.
Background Tasks: Monitor background tasks to prevent resource exhaustion.

Frequently Asked Questions

Q: Can I use checkpoints without git? A: Yes, but it’s not recommended. Checkpoints supplement, not replace, version control.

Q: How many subagents can run in parallel? A: There’s no hard limit, but resource constraints apply. Start with 2-3 and scale based on your system.

Q: Do hooks slow down development? A: Minimal overhead. Hooks run asynchronously where possible.

Q: Can I use Claude Code with local models? A: The Agent SDK supports Bedrock, Vertex AI, and Foundry. Local model support depends on provider compatibility.

Troubleshooting

Issue	Solution
Checkpoint not saving	Check disk space and permissions
Subagent timeout	Increase timeout in options or simplify task
Hook not triggering	Verify matcher regex matches tool name
API key invalid	Regenerate key from Console

Comparison with Similar Tools

Feature	Claude Code	GitHub Copilot	Cursor	Cody
Checkpoints	✅ Built-in	❌	❌	❌
Subagents	✅ Native	❌	❌	❌
Hooks	✅ Extensive	Limited	Limited	❌
VS Code Extension	✅ Beta	✅ Stable	N/A	✅
Terminal CLI	✅ Full	❌	❌	❌
Agent SDK	✅ Python/TS	❌	❌	❌

Key Differentiators

Claude Code: Best for autonomous, complex development with full control
GitHub Copilot: Best for inline code suggestions
Cursor: Best for AI-first IDE experience
Cody: Best for enterprise code understanding

Reference Links

Conclusion

Claude Code’s autonomy upgrades represent a significant leap in AI-assisted development. The combination of checkpoints, subagents, hooks, and background tasks creates a development environment where you can confidently delegate complex tasks while maintaining full control. Whether you’re refactoring a legacy codebase, building new features, or exploring experimental approaches, these tools provide the safety net and parallel processing power to work more efficiently than ever before.

Start with the VS Code extension for a gentler learning curve, then graduate to the Agent SDK for building production-ready autonomous agents tailored to your specific workflows.

Claude Code System Prompts Revealed: Inside the AI That Powers Your Coding

Dec 21, 2025

Vibe Sparking

Discover the Hidden Architecture Behind Anthropic’s AI Coding Assistant

Claude Code System Prompts

The Discovery

Ever wondered what makes Claude Code tick? Thanks to the open-source community, specifically the Piebald-AI/claude-code-system-prompts repository, we now have unprecedented visibility into the intricate system prompts that power one of the most popular AI coding assistants on the market.

This repository, maintained by the team behind Piebald, provides a comprehensive breakdown of all Claude Code’s various system prompts, updated with each new version. As of Claude Code v2.0.75 (December 20th, 2025), it covers 56 versions of changelog since v2.0.14.

Why Claude Code Has Multiple System Prompts

Claude Code doesn’t just have one single string for its system prompt. Instead, there are multiple components working together:

Component Type	Description
Conditional Prompts	Large portions added depending on environment and configs
Tool Descriptions	Builtin tools like `Write`, `Bash`, and `TodoWrite`
Agent Prompts	Separate system prompts for Explore, Plan, and Task agents
Utility Functions	AI-powered features like conversation compaction, CLAUDE.md generation

The result is 40+ strings that are constantly changing and moving within a very large minified JS file.

Key Prompt Categories

1. Main System Prompt (2,981 tokens)

The core system prompt defines Claude Code’s fundamental behavior:

Communication Style:

Responses should be “short and concise” for command-line display
Uses GitHub-flavored markdown formatted for monospace fonts
Avoids emojis unless explicitly requested
Tools are for task completion only, not user communication

Technical Approach:

Prioritizes technical accuracy and truthfulness
Provides direct, objective technical info
Reads files before proposing modifications
Avoids over-engineering and unnecessary abstractions

2. Agent Prompts

Sub-agents

Agent	Tokens	Purpose
Explore	516	System prompt for the Explore subagent
Plan Mode (Enhanced)	633	Enhanced prompt for the Plan subagent
Task Tool	294	System prompt for Task tool spawned subagents

Creation Assistants

Agent	Tokens	Purpose
Agent Creation Architect	1,111	Creating custom AI agents with detailed specifications
CLAUDE.md Creation	384	Analyzing codebases and creating CLAUDE.md files
Status Line Setup	1,310	Configuring status line display

3. Slash Commands

Command	Tokens	Purpose
/pr-comments	402	Fetching and displaying GitHub PR comments
/review-pr	243	Reviewing GitHub pull requests
/security-review	2,610	Comprehensive security review for code changes

4. Utility Prompts

Utility	Tokens	Purpose
Bash Command Prefix Detection	835	Detecting command prefixes and injection
Conversation Summarization	1,121+	Creating detailed conversation summaries
Claude Guide Agent	763	Helping users understand Claude Code
Session Title Generation	333	Generating titles and git branch names
WebFetch Summarizer	185	Summarizing verbose web fetch output

Builtin Tool Descriptions

Claude Code’s builtin tools have their own detailed descriptions:

Tool	Tokens	Description
Bash	1,074	Run shell commands with safety guidelines
TodoWrite	2,167	Task list management with best practices
Task	1,214	Launching specialized sub-agents
EnterPlanMode	970	Entering plan mode for implementation design
ReadFile	439	Reading files with multimodal support
Edit	278	Exact string replacements in files
Write	159	Creating/overwriting files
Grep	300	Content search using ripgrep

Recent Changelog Highlights

The system prompts are constantly evolving. Here are key recent changes:

v2.0.75 (December 20, 2025)

Streamlined task tool instructions
Removed directive against using colons before tool calls

v2.0.74

New “Session Search Assistant” agent for finding relevant sessions
Removed delegate mode restrictions

v2.0.73

Added “Prompt Suggestion Generator v2” with improved intent prediction
Merged slash command functionality into the Skill tool
Expanded LSP capabilities with call hierarchy operations

v2.0.71

Introduced browser automation support via new Computer tool
Chrome-based task execution enabled

v2.0.62

Major planning philosophy shift: EnterPlanMode rewritten to encourage proactive planning for non-trivial tasks

Practical Applications

For Developers

Understanding these prompts helps you:

Work more effectively with Claude Code - Knowing its priorities and constraints
Craft better prompts - Align your requests with Claude Code’s design
Debug unexpected behavior - Understand why certain responses occur

For AI Enthusiasts

This transparency offers:

Learning opportunities - Study how production AI systems are prompted
Best practices - See how Anthropic structures complex multi-agent systems
Research material - Compare prompting strategies across tools

The tweakcc Tool

Want to customize Claude Code’s system prompts? The Piebald team also created tweakcc, which lets you:

Customize individual pieces of the system prompt as markdown files
Patch your npm-based or native Claude Code installation
Manage conflicts when both you and Anthropic modify the same prompt file

About Piebald

Piebald is described as “the ultimate agentic AI developer experience.” It supports:

Multi-provider APIs: OpenAI-compatible, Anthropic-compatible, or Google-compatible
Credential imports: From Claude Code, Gemini CLI, and Codex CLI
Full customization: Prompts, model settings, and reusable profiles

Summary

The Piebald-AI/claude-code-system-prompts repository provides unprecedented insight into how Claude Code works internally:

40+ prompt strings working together
Multiple agent types for different tasks
Detailed tool descriptions guiding behavior
Constant evolution across 56+ versions

This transparency benefits the entire AI development community by showing how production AI coding assistants are architected.

Sources:

Have you explored Claude Code’s system prompts? What insights have you discovered? Share in the comments!

Hugging Face Skills: Fine-Tune Any Open-Source LLM with Natural Language

Dec 21, 2025

Vibe Sparking

Turn Conversations Into Fine-Tuned Models — No ML Expertise Required

Hugging Face Skills

What Are Hugging Face Skills?

Hugging Face Skills is a revolutionary system that enables AI coding agents like Claude Code, OpenAI Codex, and Google Gemini CLI to fine-tune open-source language models end-to-end through natural language conversations.

Instead of writing complex training scripts, configuring GPU resources, and managing deployment pipelines manually, you simply describe what you want in plain English:

Fine-tune Qwen3-0.6B on my customer support dataset for 3 epochs.

The AI agent handles everything else: data validation, hardware selection, script generation, job submission, progress monitoring, and model publishing.

Key Features and Highlights

End-to-End Automation

Capability	Description
Data Validation	Automatically checks dataset format compatibility before training
Hardware Selection	Intelligently picks the right GPU based on model size and budget
Script Generation	Creates production-ready training scripts with TRL library
Job Submission	Submits training jobs to Hugging Face cloud GPUs
Real-time Monitoring	Tracks progress via Trackio dashboard
Model Publishing	Pushes finished models to Hugging Face Hub
GGUF Conversion	Converts models for local deployment with llama.cpp/Ollama

Supported Training Methods

Method	Best For	Example Dataset
SFT (Supervised Fine-Tuning)	Quality behavior examples	Customer support conversations
DPO (Direct Preference Optimization)	Preference-annotated data	Chosen/rejected response pairs
GRPO (Group Relative Policy Optimization)	Verifiable success criteria	Math problems, coding tasks

Multi-Platform Compatibility

Anthropic Claude Code — Full integration via MCP protocol
OpenAI Codex — Uses AGENTS.md for instruction loading
Google Gemini CLI — Extensions-based integration
Coming Soon: Cursor, Windsurf, Continue

Prerequisites, Installation and Configuration

Requirements

Hugging Face Account with Pro or Team/Enterprise plan (Jobs require paid plan)
Write-Access Token from huggingface.co/settings/tokens
Coding Agent (Claude Code, Codex, or Gemini CLI)

Claude Code Installation

# Step 1: Register the Hugging Face Skills marketplace
/plugin marketplace add huggingface/skills

# Step 2: Install the LLM trainer skill
/plugin install hf-llm-trainer@huggingface-skills

Alternative: MCP-based Installation

# Add via MCP transport
claude mcp add --transport http hf-skills \
  https://huggingface.co/mcp?bouquet=skills \
  --header "Authorization: Bearer $HF_TOKEN"

OpenAI Codex Installation

Codex auto-identifies skills via the AGENTS.md file:

# Verify installation
codex --ask-for-approval never "Summarize the current instructions."

Gemini CLI Installation

# Option 1: Install from GitHub
gemini extensions install https://github.com/huggingface/skills.git --consent

# Option 2: Local installation
gemini extensions install . --consent

Authentication

# Interactive login (recommended)
hf auth login

# Or set environment variable
export HF_TOKEN=hf_your_write_access_token_here

Recommended Scenarios and Best Practices

Scenario 1: Customer Support Bot Fine-Tuning

Fine-tune Qwen3-1.7B on my-org/support-conversations
for customer service responses. Use SFT for 3 epochs.

Expected Workflow:

Agent validates dataset format (looks for “messages” column)
Selects t4-medium hardware (~$0.75/hour)
Configures training with appropriate batch size
Submits job and provides monitoring link
Pushes model to your-username/qwen-support-sft

Scenario 2: Code Assistant with Preference Learning

Stage 1: SFT on code-examples dataset
Stage 2: DPO alignment using preference-data with
chosen/rejected columns

Multi-stage Pipeline:

First stage creates base capabilities
Second stage aligns with human preferences
Agent handles both stages automatically

Scenario 3: Math Reasoning with GRPO

Train a math reasoning model using GRPO on openai/gsm8k
based on Qwen3-0.6B. Use verifiable reward signals.

Best for:

Problems with correct/incorrect answers
Code generation with unit tests
Mathematical proofs

Best Practices

Always Validate First
```
Check if my-org/training-data works for SFT training.
```
This costs pennies and prevents $30+ failures.

Start with Demo Runs

Do a quick test run on 100 examples of my dataset.

Be Explicit for Production

SFT Qwen-0.6B for production on the full dataset.
Checkpoints every 500 steps, 3 epochs, cosine learning rate.

Monitor in Real-Time
```
How's my training job doing?
```
Get live loss curves, learning rate, and ETA.

Hardware and Cost Guide

Model Size	Recommended GPU	Training Time	Est. Cost	Notes
<1B	t4-small	<1 hour	$1-2	Demo/testing
1-3B	t4-medium / a10g-small	2-3 hours	$5-15	Small production
3-7B	a10g-large (LoRA)	4-8 hours	$15-40	Medium production
7B+	Not supported	—	—	Too large for this tool

Note: Models above 3B automatically use LoRA (Low-Rank Adaptation) to fit in memory while maintaining quality.

Precautions, FAQ, and Troubleshooting

Frequently Asked Questions

Q: What’s the minimum cost to try this?

A: A demo run on 100 examples with t4-small costs approximately $0.30-0.50.

Q: Can I train models larger than 7B?

A: The current HF Skills system supports up to 7B. For larger models, use full Hugging Face infrastructure.

Q: Which dataset formats are supported?

A:

SFT: messages column with conversation format
DPO: chosen, rejected, and optionally prompt columns
GRPO: Dataset with verifiable correct answers

Q: How do I fix column name mismatches?

A: Ask the agent:

My DPO dataset uses 'good_response' and 'bad_response'
instead of 'chosen' and 'rejected'. How do I fix this?

Common Issues and Solutions

Issue	Solution
Out of Memory	Agent suggests batch size reduction or hardware upgrade
Dataset Format Error	Run validation first; agent identifies mismatches
Training Timeout	Adjust epoch count or use checkpointing
Authentication Failed	Verify HF_TOKEN has write permissions

Pro Tips

Use Trackio Dashboard — Real-time training visualization at huggingface.co/spaces/username/trackio
Convert to GGUF — Deploy locally without internet dependency
Checkpoint Regularly — Recover from interruptions without losing progress

Comparison with Similar Products and Services

Hugging Face Skills vs. Traditional Fine-Tuning

Aspect	Traditional	HF Skills
Setup Time	Hours to days	Minutes
ML Knowledge Required	Extensive	None
Hardware Management	Manual	Automated
Cost Visibility	After training	Before submission
Monitoring	Custom setup	Built-in Trackio

Coding Agent Comparison

Agent	Integration Method	Strengths
Claude Code	MCP + Plugin	Best for complex multi-step workflows
OpenAI Codex	AGENTS.md	Strong code generation
Gemini CLI	Extensions	Google ecosystem integration

Alternative Tools

Tool	Focus	Key Difference
Hugging Face AutoTrain	GUI-based training	Visual interface, less conversational
AWS SageMaker	Enterprise ML	More complex, broader scope
Google Vertex AI	Cloud ML	Tightly coupled with GCP
Together AI	Inference + Training	Focus on API-first approach

Why Choose HF Skills?

Natural language interface
No code required
Cost-effective for small-to-medium models
Seamless Hub integration

Reference Links

Official Resources

Coding Agent Documentation

Training Method References

Community Resources

Conclusion

Hugging Face Skills represents a paradigm shift in how we approach model fine-tuning. By bridging the gap between natural language and machine learning infrastructure, it democratizes access to custom AI model creation.

Whether you’re a developer looking to create a specialized code assistant, a business building a customer support bot, or a researcher exploring new training methods, HF Skills provides an accessible, cost-effective, and powerful solution.

Get Started Today:

# Install the skill
/plugin marketplace add huggingface/skills
/plugin install hf-llm-trainer@huggingface-skills

# Authenticate
hf auth login

# Start training!
"Fine-tune Qwen3-0.6B on my dataset for instruction following."

The future of AI model training is conversational. Welcome to the age of Skills.

Last updated: December 21, 2025

n8n-skills: Build Flawless n8n Workflows with Claude Code

Dec 21, 2025

Vibe Sparking

Transform Your n8n Workflow Development with AI-Powered Skills

n8n-skills Claude Code Integration

What is n8n-skills?

n8n-skills is a collection of 7 complementary Claude Code skills designed to teach AI assistants how to build production-ready n8n workflows using the n8n-mcp MCP server.

Created by Romuald Członkowski from AI Advisors, these skills solve the common challenges developers face when building n8n workflows programmatically.

Why n8n-skills Exists

Building n8n workflows programmatically can be challenging. Common issues include:

Challenge	How n8n-skills Helps
Using MCP tools incorrectly	Expert guidance on tool selection
Validation error loops	Validation error interpretation and fixing
Unknown workflow patterns	5 proven architectural patterns
Node misconfiguration	Operation-aware node configuration
Expression syntax errors	Correct {{}} patterns and variables

The 7 Skills

1. n8n Expression Syntax

Teaches correct n8n expression syntax and common patterns.

Activates when: Writing expressions, using {{}} syntax, accessing $json/$node variables.

Key Features:

Core variables ($json, $node, $now, $env)
Critical gotcha: Webhook data is under $json.body
Common mistakes catalog with fixes
When NOT to use expressions (Code nodes!)

2. n8n MCP Tools Expert (HIGHEST PRIORITY)

Expert guide for using n8n-mcp MCP tools effectively.

Key Features:

Tool selection guide (which tool for which task)
nodeType format differences (nodes-base.* vs n8n-nodes-base.*)
Validation profiles (minimal/runtime/ai-friendly/strict)
Smart parameters (branch=“true” for IF nodes)
Auto-sanitization system explained

3. n8n Workflow Patterns

Build workflows using 5 proven architectural patterns.

Key Features:

5 proven patterns (webhook processing, HTTP API, database, AI, scheduled)
Workflow creation checklist
Real examples from 2,653+ n8n templates
Pattern selection guide

4. n8n Validation Expert

Interpret validation errors and guide fixing.

Key Features:

Validation loop workflow
Real error catalog
Auto-sanitization behavior explained
False positives guide

5. n8n Node Configuration

Operation-aware node configuration guidance.

Key Features:

Property dependency rules (e.g., sendBody → contentType)
Operation-specific requirements
AI connection types (8 types for AI Agent workflows)

6. n8n Code JavaScript

Write effective JavaScript code in n8n Code nodes.

Key Features:

Data access patterns ($input.all(), $input.first(), $input.item)
Correct return format: [{json: {...}}]
Built-in functions ($helpers.httpRequest(), DateTime, $jmespath())
Top 5 error patterns with solutions (covering 62%+ of failures)
10 production-tested patterns

7. n8n Code Python

Write Python code in n8n Code nodes with proper limitations awareness.

Key Features:

Important: Use JavaScript for 95% of use cases
Critical limitation: No external libraries (requests, pandas, numpy)
Standard library reference (json, datetime, re, etc.)
Workarounds for missing libraries

Installation

Prerequisites

n8n-mcp MCP server installed and configured (Installation Guide)
Claude Code, Claude.ai, or Claude API access
.mcp.json configured with n8n-mcp server

Method 1: Plugin Installation (Recommended)

# Install directly as a Claude Code plugin
/plugin install czlonkowski/n8n-skills

Method 2: Via Marketplace

# Add as marketplace, then browse and install
/plugin marketplace add czlonkowski/n8n-skills

# Then browse available plugins
/plugin install
# Select "n8n-mcp-skills" from the list

Method 3: Manual Installation

# 1. Clone this repository
git clone https://github.com/czlonkowski/n8n-skills.git

# 2. Copy skills to your Claude Code skills directory
cp -r n8n-skills/skills/* ~/.claude/skills/

# 3. Reload Claude Code
# Skills will activate automatically

Recommended Scenarios

1. Building Webhook-to-Slack Workflows

User: "Build and validate a webhook to Slack workflow"

Skills activated:
1. n8n Workflow Patterns → Identifies webhook processing pattern
2. n8n MCP Tools Expert → Searches for webhook and Slack nodes
3. n8n Node Configuration → Guides node setup
4. n8n Code JavaScript → Helps process webhook data
5. n8n Expression Syntax → Helps with data mapping
6. n8n Validation Expert → Validates the final workflow

2. Creating AI Agent Workflows

Perfect for building intelligent automation with LangChain nodes:

AI connection types guidance
Memory and output parser configuration
Streaming mode constraints

3. Scheduled Data Processing

Build reliable scheduled workflows:

Scheduled trigger configuration
Database integration patterns
Error handling best practices

4. API Integration Workflows

Connect external services efficiently:

HTTP Request node configuration
Authentication patterns
Response handling

Best Practices

1. Start with Templates

Always check n8n’s 2,709 workflow templates before building from scratch:

"Search templates for slack notification"
→ n8n MCP Tools Expert activates
→ Returns curated template options

2. Validate Early and Often

Use the multi-level validation approach:

Level	Profile	Use Case
1	minimal	Quick required fields check (<100ms)
2	runtime	Full validation with fixes
3	ai-friendly	Balanced for AI workflows
4	strict	Complete validation

3. Understand Property Dependencies

Many n8n nodes have conditional properties:

// Example: HTTP Request node
{
  sendBody: true,    // Setting this...
  contentType: "json" // ...requires this
}

4. Use Correct Expression Syntax

// ✅ Correct
{{ $json.data.value }}
{{ $node["Previous Node"].json.result }}

// ❌ Common mistakes
{{ $json["body"]["data"] }}  // In webhook, data is under $json.body!

FAQs & Troubleshooting

Q: Why does my webhook workflow fail?

A: Remember that webhook data is under $json.body, not directly in $json. This is the most common gotcha.

// ❌ Wrong
{{ $json.userId }}

// ✅ Correct
{{ $json.body.userId }}

Q: How do I choose between Code node JS vs Python?

A: Use JavaScript for 95% of use cases. Python has critical limitations:

No external libraries (requests, pandas, numpy)
Only standard library available

Q: Validation keeps failing with false positives

A: Use appropriate validation profiles:

minimal for quick checks during development
runtime for production-ready validation
Check the auto-sanitization behavior

Q: Which MCP tools should I use first?

A: Follow this order:

search_templates - Check if templates exist
search_nodes - Find required nodes
get_node - Get configuration details
validate_node - Validate your config
validate_workflow - Final check

Product Comparison

n8n-skills vs Building Manually

Aspect	With n8n-skills	Without
Learning curve	Guided by AI	Self-discovery
Error handling	Proactive patterns	Trial and error
Best practices	Built-in	Research required
Validation	Multi-level automated	Manual testing

n8n vs Other Automation Tools

Feature	n8n	Zapier	Make
Self-hosted	✅	❌	❌
Code nodes	✅ Full JS/Python	Limited	Limited
AI integration	✅ LangChain	Basic	Basic
Open source	✅	❌	❌
MCP support	✅ via n8n-mcp	❌	❌

Tool	Purpose
n8n-mcp	MCP server for n8n (required)
n8n	Workflow automation platform
Claude Code	AI coding assistant

What’s Included

7 complementary skills that work together
525+ n8n nodes supported
2,653+ workflow templates for examples
10 production-tested Code node patterns
Comprehensive error catalogs and troubleshooting guides

Summary

n8n-skills transforms the way you build n8n workflows with Claude Code:

Automatic activation - Skills trigger when relevant queries are detected
Composable design - All 7 skills work together seamlessly
Production-ready patterns - Based on real-world usage
Validation first - Catch errors before deployment

Whether you’re building simple webhook integrations or complex AI agent workflows, n8n-skills provides the guidance you need to build flawless automation.

Reference Links:

Ready to supercharge your n8n workflow development? Install n8n-skills today and let AI guide your automation journey!

BMAD Installation & Configuration Guide: Best Practices for Project-Level Setup

Dec 20, 2025

Vibe Sparking

BMAD (Build More, Architect Dreams) is an AI-driven agile development methodology framework that integrates multiple AI Agents, workflows, and modules. It supports 18+ IDEs including Claude Code, Codex, and Cursor. This guide walks you through the complete installation and configuration process for BMAD v6.0.0-alpha.

1 | Why Project-Level Installation?

Key Recommendation: Install BMAD in your project directory, NOT in your user home directory.

Benefits:

Isolation: Each project has independent BMAD configuration
Version Control: Project-level config can be tracked with Git
Team Collaboration: Team members get identical configs when cloning
Multi-Project Support: Different projects can use different BMAD versions

Post-installation directory structure:

Project Directory Structure

The .bmad configuration directory contains these submodules:

BMAD Directory Structure

2 | Prerequisites

Ensure you have:

Node.js (v18+ recommended)
Bun or npm/npx
Claude Code or another supported IDE

3 | Starting Installation

Run in your project root directory:

bunx bmad-method@alpha install

You’ll see the BMAD ASCII logo:

    ██████╗ ███╗   ███╗ █████╗ ██████╗ ™
    ██╔══██╗████╗ ████║██╔══██╗██╔══██╗
    ██████╔╝██╔████╔██║███████║██║  ██║
    ██╔══██╗██║╚██╔╝██║██╔══██║██║  ██║
    ██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝
    ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝
    Build More, Architect Dreams v6.0.0-alpha.16

4 | Configuration Options Explained

4.1 Installation Directory

? Installation directory: /Users/vsai/WorkSpaces/vs/vs-ai-agents
? Install to this directory? Yes

Recommendation: Use your current project directory and confirm with Yes.

4.2 BMad Optimized Builder (BoMB) Module

? Where do custom agents and workflows get stored? bmad-custom-src
? Where do custom modules get stored? bmad-custom-modules-src

Option	Recommended Value	Description
Custom agents/workflows	`bmad-custom-src`	Stores custom Agents and workflows
Custom modules	`bmad-custom-modules-src`	Stores custom modules

4.3 Game Development Module

? What is the name of your game project? vs-ai-agents
? Where should Sprint Artifacts be stored? docs/sprint-artifacts
? What is your game development experience level? Expert
? Which game development framework or engine? Unity, Unreal Engine, Godot, Custom / Other

Option	Possible Values	Description
Project name	Custom	Your game project name
Sprint Artifacts directory	`docs/sprint-artifacts`	Stores stories, epics, temp context, etc.
Experience level	Beginner / Intermediate / Expert	Affects how Agents explain concepts
Game engine	Unity / Unreal / Godot / Custom	Your game development framework

4.4 BMad Method Core Configuration

? What is the title of your project? vs-ai-agents
? What is your technical experience level? Expert - Deep technical knowledge
? Where should Sprint Artifacts be stored? docs/sprint-artifacts
? Enable Test Architect Playwright MCP capabilities? Yes
? Are you using playwright-utils in your project? Yes

Option	Recommended	Description
Project title	Your project name	Used for Agent context
Technical experience	Choose as appropriate	Only affects explanation style, NOT document content
Playwright MCP	Yes	Enables Test Architect automation capabilities
playwright-utils	As needed	Advanced features from `@seontechnologies/playwright-utils`

Note: Technical experience level only affects how Agents communicate with you. Documents always remain concise for LLM efficiency.

4.5 Codex CLI Prompts Location (Critical)

This is one of the most important choices during installation:

? Where would you like to install Codex CLI prompts?
  > Project-specific - Recommended for real work (requires CODEX_HOME=<project-dir>/.codex)
    Global - Simple for single project (~/.codex/prompts)

Strongly Recommended: Choose Project-specific

Why Project-Specific?

Method	Pros	Cons
Project-specific	Project isolation, version controllable, team sharing	Requires environment variable setup
Global	Simple configuration	Only serves single project, references fixed `.bmad` path

Environment Variable Setup

After choosing Project-specific, add to your ~/.bashrc or ~/.zshrc:

alias codex='CODEX_HOME="$PWD/.codex" codex'

Then run:

source ~/.bashrc  # or source ~/.zshrc

This alias makes Codex CLI automatically use the .codex config in your current working directory.

5 | Understanding Installation Logs

During installation, you’ll see module installation progress:

✔ Core installed
✔ Dependencies resolved
✔ Module installed: bmb      # BMad Optimized Builder
✔ Module installed: bmgd     # BMad Game Development
✔ Module installed: bmm      # BMad Method
✔ Module installed: cis      # Creative Innovation Suite
✔ Module configurations generated
✔ Manifests generated: 61 workflows, 21 agents, 5 tasks, 1 tools, 88 files
✔ Configured 18 IDEs

Installed Modules

Module	Full Name	Purpose
bmb	BMad Optimized Builder	Agent and workflow builder
bmgd	BMad Game Development	Game development-specific Agents
bmm	BMad Method	Core agile methodology
cis	Creative Innovation Suite	Creative and innovation tools

Generated Agents

Compiled agents:
- bmad-master, bmad-builder
- game-architect, game-designer, game-dev, game-scrum-master
- analyst, architect, dev, pm, sm
- quick-flow-solo-dev, tea, tech-writer, ux-designer
- brainstorming-coach, creative-problem-solver
- design-thinking-coach, innovation-strategist
- presentation-master, storyteller

6 | AgentVibes TTS Configuration (Optional)

After installation, you’ll be prompted to configure AgentVibes voice synthesis:

🎙️  AgentVibes TTS Setup
AgentVibes provides voice synthesis for BMAD agents with:
  • ElevenLabs AI (150+ premium voices)
  • Piper TTS (50+ free voices)

If you choose to install, it automatically configures:

34 slash commands
TTS scripts
16 background music tracks
Personality templates

Using AgentVibes

# Launch Claude Code with MCP
claude --mcp-config .mcp.json

# AgentVibes commands
/agent-vibes:list              # View all available voices
/agent-vibes:switch <name>     # Switch voice
/agent-vibes:personality <style>  # Set personality style

7 | Post-Installation Directory Structure

your-project/
├── .bmad/
│   ├── _cfg/           # Configuration files
│   ├── bmb/            # Builder module
│   ├── bmgd/           # Game development module
│   ├── bmm/            # Method core module
│   ├── cis/            # Creative innovation module
│   ├── core/           # Core Agents
│   └── docs/           # Documentation
├── .claude/            # Claude Code config
├── .codex/             # Codex CLI config (project-level)
├── bmad-custom-src/    # Custom Agents
├── bmad-custom-modules-src/  # Custom modules
└── docs/
    └── sprint-artifacts/  # Sprint artifacts

8 | Verifying Installation

After installation, verify with:

In Claude Code

claude --mcp-config .mcp.json

Then try:

/bmad-bmm-agents-pm    # Activate PM Agent

View Available Agents

ls .bmad/core/agents/
ls .bmad/bmm/agents/

9 | FAQ

Q: How do I update BMAD?

bunx bmad-method@alpha install --update

Q: How do I use BMAD in multiple projects?

Run the installation command in each project. Project-level configurations don’t interfere with each other.

Q: Codex can’t find prompts?

Ensure you’ve configured the CODEX_HOME environment variable and are running codex from within your project directory.

10 | Summary

Configuration	Recommended Choice
Installation location	Project directory (not Home)
Codex installation	Project-specific
Technical level	Choose as appropriate, doesn’t affect document quality
Playwright MCP	Enable (for automated testing)
AgentVibes	Install as needed

BMAD’s project-level installation allows you to:

Use different configurations across projects
Version control your AI Agent configurations
Share consistent development environments with team members

Start using BMAD and let AI Agents become your agile development partners!

Resources

Claude Chrome Extension: Bringing the Power of Claude Code to Everyday Tasks

Dec 20, 2025

Vibe Sparking

Claude Chrome Extension: The “ChatGPT Moment” for Claude Code has arrived.

When Claude Code steps out of the dialog box and into your Chrome browser.

Introduction: Anthropic’s “ChatGPT Moment”

Remember the shock when ChatGPT was first released? In that moment, AI moved from the lab into millions of homes.

Now, Anthropic is creating its own “ChatGPT moment”—not through a chat box, but via the Claude Chrome Extension, turning AI into a true “digital employee” within your browser.

The Claude Chrome Extension brings the powerful capabilities of Claude Code to ordinary users—you don’t need to know how to code or understand APIs. Just tell Claude what you want to do in your browser, and it will do it for you.

This is more than just a browser plugin; it’s a significant step toward integrating AI into daily workflows.

What is the Claude Chrome Extension?

With the Claude Chrome Extension, you can direct Claude to perform tasks directly in your browser.

The extension enables Claude to:

Navigate Webpages: Automatically open and browse any website.
Click Buttons: Simulate user actions and execute clicks.
Fill Forms: Automatically populate various forms and input fields.
Execute Background Tasks: You can continue with other work while Claude works in the background.
Schedule Workflows: Set up daily or weekly automated tasks.

Core Capabilities: Four Key Scenarios

1. Seamless Collaboration with Claude Code

Developers can connect Chrome directly within Claude Code to:

Test and iterate on code in-browser.
Automate front-end testing processes.
Achieve a perfect blend of development and debugging.

2. Integration into Daily Tools

The Claude Chrome Extension can operate the applications you use every day:

Google Drive file organization.
Calendar management and meeting preparation.
CRM system data entry.
Email cleanup and categorization.

3. Background Task Execution

Once the Claude Chrome Extension starts a workflow, you can move on to other things:

Claude will quietly complete tasks in the background.
It doesn’t require your active attention.
Results are automatically synchronized.

4. Scheduled Workflows

Set up periodic tasks without manual triggers:

Daily data report generation.
Weekly progress updates.
Regular data synchronization and backups.

Real-world Use Cases

Scenario	What the Claude Chrome Extension Can Do
Analyze Dashboard Data	Navigate to analytics platforms, extract metrics, and report.
Organize Google Drive	Scan files, create folder structures, and auto-archive.
Calendar Prep	Read schedules, extract context from emails, and flag prep.
Cross-site Comparison	Read multiple product pages and generate comparison tables.
CRM Call Logs	Match participants and contacts to generate activity logs.
Clean Promotional Emails	Scan inboxes, identify marketing/newsletters, and bulk process.

Anthropic vs OpenAI: A Shifting Competitive Landscape

The release of the Claude Chrome Extension is a strategic move for Anthropic. Let’s look at the latest market data:

Revenue Comparison

Metric	Anthropic	OpenAI
2024 Revenue	$1 Billion	$3.7 Billion
2025 Forecast	$7 Billion+	$12.7 Billion
Growth Rate	8000% (21 months)	243%

User Comparison

Metric	Claude	ChatGPT
Monthly Active Users	18.9 Million	800 Million Weekly
Enterprise Customer Share	70-80%	-

Key Insights

The gap is closing rapidly:

At the start of 2024, OpenAI was 15 times the size of Anthropic.
By the end of 2024, this gap narrowed to 5 times.
Anthropic’s ARR has reached 40% of OpenAI’s.

The enterprise market is Anthropic’s stronghold:

Claude’s consumer user base is only 5% of ChatGPT’s.
Yet, with an ARR reaching 40%, it’s clear that enterprise customers are contributing significantly.
Enterprise clients represent more stable revenue and higher average transaction values.

Why is this a “ChatGPT Moment”?

ChatGPT’s success lay in making AI conversations accessible to everyone. The Claude Chrome Extension does the same, but in a different direction:

From Conversation to Action: While ChatGPT taught people to talk to AI, Claude allows AI to actually do things for you.
From Developers to Everyday Users: The power of Claude Code is now available to everyone.
From Standalone Tools to Global Assistants: It’s no longer just a web app, but an integrated part of the entire browsing experience.

This is precisely the breakthrough Anthropic needs—using a differentiated product experience to carve out a new track in a market dominated by ChatGPT.

How to Get Started?

Visit the Chrome Web Store to install the extension.

Click the extension icon and select “Open Claude” to begin.
Start with simple tasks and gradually explore more complex workflows.

Can also be used in conjunction with Claude Code or Claude Desktop.

Security Tips

While the Claude Chrome Extension is powerful, please keep in mind:

Start by using it on trusted websites.
Exercise extra caution with sensitive operations involving finances or passwords.
If you notice any unusual behavior, pause the extension and provide feedback immediately.

Conclusion

The Claude Chrome Extension represents a new direction in AI development:

Beyond Chat: True task execution.
Beyond Developer Tools: Accessible to everyone.
Beyond Feature Bloat: A revolution in workflow.

For Anthropic, this could be the key step in shifting the market landscape. While ChatGPT remains far ahead in user numbers, Anthropic is catching up in a different way—deeper enterprise integration and closer alignment with actual work.

In the second half of the AI competition, it’s no longer just about whose dialogue is smarter, but who can actually help users get things done.

References

Claude Code + MCP: Auto-Publish Articles to WeChat Official Account in Minutes

Dec 20, 2025

Vibe Sparking

Claude Code MCP WeChat Automation

Introduction

What if you could go from a simple idea to a fully researched, professionally written article published to your WeChat Official Account - all in minutes, without leaving your terminal?

This isn’t science fiction. With Claude Code and the wenyan-mcp (Model Context Protocol) server, you can create an end-to-end content automation pipeline that:

Researches topics using web search
Generates high-quality bilingual articles
Automatically publishes to your WeChat draft box
Applies beautiful formatting themes

Let me show you exactly how to set this up.

What You’ll Need

Before we begin, make sure you have:

Claude Code installed (v2.0+ recommended)
Docker running on your machine
WeChat Official Account with API credentials (AppID and AppSecret)

Step 1: Install Claude Code

If you haven’t installed Claude Code yet:

# Using npm
npm install -g @anthropic-ai/claude-code

# Or using Homebrew (macOS)
brew install claude-code

Verify installation:

claude --version
# Claude Code v2.0.74

Step 2: Configure wenyan-mcp for WeChat

The magic happens through MCP (Model Context Protocol) - a standard that allows Claude to interact with external tools and services.

Add this configuration to your Claude Code MCP settings (~/.claude/settings.json or project-level .claude/settings.local.json):

{
  "mcpServers": {
    "wenyan-mcp": {
      "name": "公众号助手",
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-v",
        "/path/to/your/images:/mnt/host-downloads",
        "-e",
        "WECHAT_APP_ID=your_wechat_app_id",
        "-e",
        "WECHAT_APP_SECRET=your_wechat_app_secret",
        "-e",
        "HOST_IMAGE_PATH=/path/to/your/images",
        "caol64/wenyan-mcp"
      ]
    }
  }
}

Configuration Notes:

Parameter	Description
`WECHAT_APP_ID`	Your WeChat Official Account AppID
`WECHAT_APP_SECRET`	Your WeChat Official Account AppSecret
`HOST_IMAGE_PATH`	Local path for image storage (used for cover images)
`-v` mount	Maps your local image directory to the container

Tip: Get your AppID and AppSecret from the WeChat Official Account Admin Platform.

Step 3: Create an Issue File

The key to this workflow is defining your task in an issue file. This tells Claude exactly what you want to accomplish.

Create a file like engineering/00-issues/my-article-task.md:

---
slug: engineering/00-issues/my-article-task
---

# Issue: Write a blog about [Your Topic]

## Description

Key points to cover:

- Point 1
- Point 2
- Point 3

## Requirements

- Languages: Chinese Simplified, English
- Use `wenyan-mcp` to publish (Chinese Simplified)
- Research latest trends and data

Step 4: Execute the Workflow

Now comes the exciting part. Start Claude Code and reference your issue:

claude

Then in the Claude Code prompt:

Execute @engineering/00-issues/my-article-task.md

Starting Claude Code

What Happens Next (Automatically)

1. Research Phase

Claude searches the web for relevant, up-to-date information:

2. Content Synthesis

Claude fetches and analyzes multiple sources to create comprehensive content:

Browsing Articles

3. Article Generation & Publishing

Claude generates the article and publishes directly to your WeChat draft box:

Task Completed

4. Review in WeChat

Open your WeChat Official Account admin panel - your article is waiting in the draft box:

WeChat Draft Box

Article Preview

Available Themes

The wenyan-mcp server supports multiple beautiful themes for your articles:

Theme	Style
`default`	Clean, minimal
`orangeheart`	Warm orange accents
`rainbow`	Colorful headings
`lapis`	Professional blue
`pie`	Playful design
`maize`	Golden highlights
`purple`	Elegant purple
`phycat`	Tech-focused

Specify your preferred theme when publishing:

Use the orangeheart theme when publishing to WeChat

Complete Workflow Summary

┌─────────────────────────────────────────────────────────────┐
│                    YOUR WORKFLOW                             │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   1. Define Issue          📝 Create task in .md file       │
│          ↓                                                   │
│   2. Start Claude Code     💻 Execute the issue             │
│          ↓                                                   │
│   3. Auto Research         🔍 Web search & analysis         │
│          ↓                                                   │
│   4. Generate Content      ✍️  Bilingual articles           │
│          ↓                                                   │
│   5. Publish to WeChat     📱 Direct to draft box           │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Pro Tips

1. Multi-Language Output

Specify languages in your issue file:

Languages: Chinese Simplified, English

Claude will generate both versions automatically.

2. Include Screenshots

Reference local images in your issue:

## Screenshots

![Step 1](path/to/screenshot1.png)

3. Customize Output Location

Specify where you want your blog files saved:

Output to: src/content/docs/blog/my-topic/

4. Review Before Final Publish

Articles go to your draft box first - you always have a chance to review and edit before final publication to subscribers.

Troubleshooting

Issue	Solution
Docker connection failed	Ensure Docker Desktop is running
WeChat API error	Verify AppID/AppSecret are correct
Images not uploading	Check HOST_IMAGE_PATH is correctly mapped
MCP server not found	Run `claude mcp list` to verify configuration

Conclusion

This workflow transforms content creation from a tedious multi-step process into a streamlined, automated pipeline. With Claude Code + wenyan-mcp, you can:

Save hours on research and writing
Maintain consistency across bilingual content
Publish directly without copy-paste gymnastics
Focus on ideas rather than execution

The future of content creation is here - and it lives in your terminal.

References

Daily Journal - 2025-12-17 Accenture and Anthropic partnership

Dec 17, 2025

Vibe Sparking

Accenture and Anthropic launch multi-year partnership to move enterprises from AI pilots to production

[[Forward Deployed Engineer]] / [[Reinvention Deployed Engineer]]
- Approximately 30,000 Accenture professionals that will be trained on Claude, including forward deployed engineers (also known as “reinvention deployed engineers” at Accenture) who help embed Claude within client environments to scale enterprise AI adoption. This will comprise one of the largest ecosystems of Claude practitioners in the world. These teams combine Accenture’s AI, industry, and function expertise—along with deep partnerships with leading cloud providers—with Anthropic’s Claude models and Claude Code, plus its proven playbooks for regulated industries.
[[Methodology]]
- quantify real productivity gains and ROI
- workflow redesign for AI-first development teams
- change management and training that keeps pace as AI evolves
[[Customization]]
- Anthropic and Accenture will also co-invest in a Claude Center of Excellence inside Accenture, creating a dedicated environment for the joint design of new AI offerings tailored to specific enterprise needs, industry requirements, and regulatory contexts.

Source: Accenture and Anthropic launch multi-year partnership to move enterprises from AI pilots to production

Anthropic Legal Turned Contract Review Drudgery Into a Workflow Art With Claude

Dec 9, 2025

Vibe Sparking

Yesterday Anthropic published a new article explaining how their legal team uses Claude / Claude Code to compress work that used to take days into a few hours—while keeping humans in the loop the whole time.

1. Even at a top AI company, legal is still squeezed by grunt work

Anthropic product counsel Mark described his earlier routine:

Replying to compliance documents and customer questionnaires
Editing terms of service and privacy policies
Reviewing blogs, emails, and marketing assets for the marketing team
Redlining contracts and comparing versions line by line
Writing a stack of privacy impact assessments (PIA)

These tasks share a few traits:

Repetitive, similar formats, high cost for mistakes, and extremely brain-draining.

He even said many things get pushed to the end of the day because they take so much time yet barely use “the best part of his brain.”

Sound familiar? If you have ever touched legal, compliance, risk, operations, or customer support, you have felt the same pain.

The Anthropic legal team did something very engineer-like:

They held a meeting and wrote on a whiteboard— “What drains the most energy? What repeats the most? What tasks do not deserve this much of our time?”

Once they had answers, they did not rush to “what AI can do.” They focused on a single question:

Which tasks do we never want to do by hand again?

2. How to break down legal workflows: 4 real scenarios

Over a few months, Anthropic’s legal team turned their pain points into repeatable workflows.

1) Self-serve marketing review: AI is the first gate

You have surely seen the previous flow:

On the night before launch, marketing would dump landing pages, push copy, and posters on legal: “Please review today; we go live tomorrow.”

Legal had to open the docs -> read end to end -> leave a pile of comments -> go back and forth for multiple rounds. It often dragged on for days.

Anthropic’s rebuild is simple but ruthless:

They built a Self-Review Tool in Slack:

Marketing pastes the copy into it
Claude calls a dedicated legal Skill file
- It contains: past review comments, common risk points, and the team’s judgment criteria
Claude automatically flags:
- Exaggerated claims?
- Is there a source for the data?
- Any violation of portrait rights or reputation?
- Any implication of promises that should not be made?
Assigns a risk level to each issue: Low / Medium / High
Also provides a suggested revision

Only after passing this gate will a ticket be created and enter the legal queue.

StartupHub reported that with this flow, reviews that took days now compress to a few hours, and Slack can auto-generate a summary to help legal see the risk points clearly.

The essence:

Let AI handle the “intake form” and “basic checkup.” The true diagnosis still belongs to the doctor.

2) Side gig / external activity approval: AI asks for details first

Many companies have similar processes:

If an employee wants to moonlight as an adviser, pursue a side business, or serve on a nonprofit board, they must go through “external business activity approval.”

Previously, legal would ask one-on-one about background, conflicts of interest, time commitments, and non-compete risks—going back and forth endlessly.

Here is how Anthropic runs it now:

The employee fills out a structured form
Claude reads the form
If information is missing, it will automatically ask follow-up questions
Based on company rules, it provides a recommended decision + risk explanation
It then enters the legal queue for an attorney to confirm approval or rejection

Lawyers now mainly focus on two buckets:

True edge cases
Higher-risk borderline situations

They separated “90% standard flow + 10% extreme judgment.”

3) Privacy impact assessments (PIA): teach AI to write the template

For privacy projects, every new feature needs a fresh PIA.

The pain:

Templates look similar, but you still have to rewrite them each time
It must fit the specific scenario without missing required sections

Anthropic’s approach has two steps:

Use MCP (Model Context Protocol) to connect Claude to a Google Drive folder
- Inside are all historical PIA documents
Equip Claude with a “PIA writing Skill” that spells out:
- Document structure
- What to focus on in each section
- Privacy points the company cares about most

An attorney just says:

“Using the previous cases, draft a PIA for this new feature.”

Claude will:

First learn the style of past PIAs
Then draft in the same format
Transfer historical focus points into the new scenario

The work shifts from “write from scratch” to “edit an 80-point draft.”

4) Legal built a “Morse code lamp,” but the point is that the barrier dropped to human language

There is a fun detail:

Mark used Claude Code to build a “legal desk lamp” that blinks Morse code to send and receive messages—purely a personal hobby project.

But the story highlights something important:

Even a lawyer who cannot code can, by “speaking human language” to AI, build a complete mini app.

For companies, this means:

Legal, compliance, and operations—the people who do not code—can build workflows themselves
No need to first line up engineering resources or launch a big project
As long as they explain the rules clearly, AI can help turn them into tools

It fundamentally changes the belief that “only engineers can build tools.”

3. The building blocks under this legal workflow

Anthropic’s legal system rests on three building blocks:

1) Swap “what tech can do” for “what I refuse to do”

Mark’s advice is blunt:

Do not start with “what AI can do.” Start with “what work do we most want to escape.”

They followed that approach on a whiteboard:

Which documents are repetitive
What judgment calls we make every day
Which flows can be fully standardized

After confirming, they checked:

Can AI do the first pass
Reserve human time for disputes, exceptions, and strategic judgment

2) Skills: package team experience into callable assets

The official blog defines Skills as a document with instructions, scripts, and references that let Claude act like an expert for a task.

For legal, Skills do two things:

Keep rules consistent
- Marketing review Skill: bakes in historical review comments
- Different domains get different Skills: employment, commercial, privacy, corporate governance…
Keep the voice consistent
- Mark had Claude read 10 of his memos
- He taught it his structure and tone
- When Claude drafts memos later, it can “write in his style”

Think of a Skill as:

A senior lawyer’s “plug-in memory card.”

Plug it in when needed; pull it out when you do not.

3) MCP: turn scattered info into a “legal knowledge web”

Another key block is MCP (Model Context Protocol).

Anthropic’s legal team connected Claude to:

Google Drive: historical contracts, PIAs, templates, policies
JIRA: requests and tickets
Slack: conversation records
Calendar: key meetings and approval checkpoints

This yields two effects:

AI stops “hallucinating” because it can check your own materials
Each workflow gets just enough context

You can think of it simply:

MCP = connect AI to your “company intranet.”

Skills = teach it “how to use those materials to get work done.”

4. The single most important rule: humans must not be absent

Both Anthropic’s blog and the StartupHub article keep repeating: “Legal must stay human-in-the-loop.”

In practice:

AI handles:
- First-pass review and issue spotting
- Initial risk grading
- Drafting suggested edits and documents
Attorneys handle:
- Fact-checking and citations
- Deciding “can the company accept this risk”
- Final external sign-off

Anthropic is explicit:

AI hallucinates; that is a fact.

So the design is: AI as accelerator, humans as brakes and steering.

For anyone rolling out AI in a company, keep this in mind:

You are not replacing legal with AI. You are using AI so legal stops being a “format fixer and typo hunter.”

5. How teams can “copy the homework”

After discussing Anthropic, let’s talk about borrowing the idea. Whether you use Claude, ChatGPT, DeepSeek, or your own model, you can follow the same playbook.

Here is how to start:

1) List your team’s “legal hell list”

Pick a day and gather legal, compliance, marketing, and product:

Write down the tasks you never want to do for the hundredth time
Prioritize by “repeatability x risk control”
Pick one or two that are ready to pilot now

Typical candidates:

First-pass marketing review
Standard clause comparison in contracts
Data protection and privacy templates
Standard questionnaires and compliance Q&A

2) Start with “human + AI dual-layer flow,” then talk automation

Jumping straight to “end-to-end auto-approval” often dies on risk and trust.

A steadier way:

Let AI handle “internal pre-review + draft assistance”
Keep the real decision flow unchanged
Use one to two months to check:
- Does it make obvious mistakes?
- Is speed truly better?
- Does the team find it more usable?

Once it passes, consider upgrading to:

Self-serve tools
Workflows wired into internal systems
Added templates, Skills, and team norms

3) Feed AI your “rules” and “style” over time

Follow Anthropic’s two-step method:

Rules
- Compile a “company legal review checklist”
- For example: banned words, mandatory disclaimers, data points that must be verified
- Turn it into a long-lived “AI prompt doc” or Skill
Style
- Give AI a few contract reviews or memos your team likes
- Have it summarize: common structure, phrasing habits, tone preferences
- Require all future drafts to “follow this style”

Gradually, you will have:

An AI teammate that works the way you do.

4) Do not forget to count the gains

Is the automation worth it? Anthropic’s “How Anthropic teams use Claude Code” notes that many teams measure efficiency this way, and legal shows especially clear returns.

You can quantify quickly:

Average review time per marketing asset
Cycle time from “sent to legal” to “legal response” for each contract
Hours per week each attorney spends on repetitive documents

Do a before-and-after, and it becomes easy to justify more resources.

6. A quick wrap-up

In one line, Anthropic Legal’s practice is:

Use AI as a rules-aware junior assistant to free senior lawyers from grunt work so they can do real judgment.

For anyone who understands the business and a bit of AI, this is a huge opportunity:

You can be the person who packages team knowledge into Skills
You can build the first “AI + legal workflow”
You can turn AI from a “chat toy” into true “process infrastructure”

I am curious:

In your team, what could be handed to AI to handle the groundwork if you follow Anthropic’s approach?

Give Claude Long-Term Memory: Hands-on Guide to claude-mem

Dec 9, 2025

Vibe Sparking

claude-mem actually lets Claude genuinely “remember you”

Do you ever feel like this:

Every time you open Claude / ChatGPT to write code, you have to re-explain the project from scratch:

“I’m building an admin console, the stack is…” “Last time we stopped at user login; this time we need to add…”

Halfway through explaining, you’re already annoyed.

The model isn’t dumb; it just has no memory.

Today, let’s look at a fun little GitHub project: claude-mem—a “long-term memory” add-on for Claude Code.

1. What exactly does claude-mem do?

In one sentence:

It automatically records what you do in Claude Code, summarizes and compresses it, and the next time you open the same project, Claude will “actively recall” past context.

More specifically, it is:

A Claude Code plugin
Automatically captures: your prompts, tool calls, file reads/writes, etc.
Uses Claude’s Agent SDK in the background to summarize and extract key points
Stores them in a local database and vector store; supports full-text + semantic search
When you reopen Claude Code, it injects the most relevant history back into the new conversation automatically

So the experience is:

You keep coding, and Claude becomes the partner who remembers the project background even better than you do.

2. How does it give Claude “memory buffs”?

The official README has a clear flowchart; here’s the plain-language version:

1) Session start: feed it “recent events”

Each time you start a new session in Claude Code, claude-mem digs out “recent key info” from the database, organizes it into a concise context block, and injects it automatically at the top of the conversation.

It’s like running through, in your head, before meeting a friend:

“Last time we talked about login and signup—what pitfalls did we hit?“

2) While you code: it quietly takes notes

Throughout the development session, it keeps recording:

Important prompts you send to Claude
The “observations” from Claude’s tool calls (which files were read, what was written)
Some critical intermediate steps

These raw snippets are not replayed wholesale as context. Instead, they’re sent to the Worker Service, which uses Claude’s Agent SDK to summarize:

“What are the takeaways worth remembering from this session?”

For example:

We decided to drop a certain third-party library
Refactored the interface design of a module
Fixed a nasty bug and summarized its root cause

3) Session end: generate a “study note”

When the session ends, it does one more thing:

Condenses the entire session into a “project changelog + decision digest.”

That gets stored in local SQLite (for full-text search) while also being written to a vector database like Chroma for semantic search.

Next time Claude looks up history, it won’t rummage through everything. It uses smart search + progressive disclosure to inject a small but crucial slice of context back into the chat.

3. What’s in it for developers?

1) Long-running projects: no more endless recaps

Picture a real scenario.

You’re building a SaaS admin console over 3 months, constantly interrupted by meetings and changing requirements.

Without claude-mem, every return to the project looks like this:

Skim Git logs and docs first
Paste a long prompt to explain the background to Claude
Only then does Claude get into the groove

With claude-mem installed:

As soon as a new session opens, Claude already knows:
- What the project is about
- Which modules changed recently
- Which pitfalls you’ve hit so you don’t repeat them

You only need to say:

“Pick up where we left off on permissions and finish the export feature.”

Claude can “follow the thread” instead of looking lost.

2) mem-search: a “project time machine”

claude-mem also ships a neat skill: mem-search.

You can ask it in natural language:

“Find how we designed the login API before.”
“That file upload bug—how did we fix it back then?”

Unlike a basic code keyword search, mem-search looks through conversations + tool calls + summarized knowledge, and lets you control how much context to inject via progressive disclosure, saving tokens.

Simply put:

It turns “I vaguely remember we discussed this” into “I can surface it on demand.”

3) Web UI: see what Claude is “thinking” in real time

The project provides a Web Viewer at http://localhost:37777 by default:

Watch the current session’s “memory stream” in real time
Search history
Check exactly what got recorded and what will be injected

For privacy-conscious teams, this matters a lot. You can visually confirm whether anything sensitive was stored.

4) Privacy control: block with a tag

If you have sensitive content (internal systems, secrets, user data), wrap it in <private> and claude-mem will exclude it from persistence.

The model can still use that info within the current session, but it won’t be written into long-term memory, reducing leakage risk.

That’s a nice plus for compliance-focused orgs.

4. How to install? Is it hard?

The author made installation match Claude Code habits closely.

In Claude Code’s terminal, open a new session and run two lines:

/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

Restart Claude Code and it starts working automatically.

More advanced (optional) moves:

Run the local worker service and Web UI
Tune configs (what to record, token strategy, etc.)
Customize settings or integrate with more complex environments

For most developers, the default setup is already great. Once you’re hooked, explore docs on “Context Engineering” and “Progressive Disclosure” later.

5. Who is it for? Any pitfalls?

Best suited for

These groups will feel the biggest gains:

Lead developers on long projects If you spend a year on one big project, you’ll love it.
People who rely on Claude Code as their primary IDE helper Daily AI pair programming makes memory benefits obvious.
Side project / open-source enthusiasts If you pause for a week or two, you can still “resume seamlessly.”

Maybe less critical

Just occasionally asking Claude to write a small script
One-off experiments or single-file utilities

At that intensity, claude-mem’s long-term memory edge is minor—install it if you feel like it.

Potential pitfalls

Requires running a local daemon and database
Team use needs data storage and access policies
It’s a community project; you need to watch upgrades and compatibility

That said, judging by stars and activity, the community is healthy. If you hit issues, open an Issue and discuss.

6. A pragmatic ROI view

From a time/money perspective, claude-mem pays off mainly by:

Saving time No more repeating project context or digging through old chats.
Reducing mistakes Avoid re-hitting old pitfalls; remember prior decisions.
Stabler collaboration When projects pause or team members change, history is easier to restore.

If you’re already paying for Claude / GPT, every “re-explaining the project” burns tokens. claude-mem essentially helps you:

Turn “explaining repeatedly” into “explain once, reuse many times.”

Summary: make AI the “teammate with great memory”

For many people, AI is now essential to daily development. But an AI without memory is more like a short-term intern:

Capable in the moment
Limited long-term project value

A “memory add-on” like claude-mem upgrades it into a long-term teammate who truly understands the project context.

If you’re already coding with Claude Code, set aside an hour on the weekend to install it and try:

You might suddenly realize— the real ceiling of LLMs isn’t “how much code they write,” but “how much of the journey they can remember.”

Question to ponder

How are you making AI “remember projects” today?

Handwritten docs?
Copy-pasting giant prompts each time?
Or simply giving up and letting it remember whatever it can?

Share your approach in the comments, or how you’d use claude-mem for your projects.

Anthropic Internal AI Development Survey: Frontend Shines, Architecture Is Hardest to Hand Off to AI

Dec 3, 2025

Vibe Sparking

Introduction: Is AI Really Making Engineers More Productive?

This year, every developer friend around me keeps asking the same question:

“I use Claude/Copilot every day, but is it really worth it? Are the vendors overselling me?”

Coincidentally, Anthropic turned the real usage data of 132 internal engineers and researchers into a detailed survey and interviews, plus several charts.

It is like an AI vendor giving itself a physical exam. Who is delighted, who is stumbling—everything is written in the numbers.

Let’s look at the report from a working engineer’s perspective and talk about: In software engineering, which tasks have the highest ROI with AI, and which ones should you not rush to offload to a model?

I. What Kind of Internal Survey Is This?

Anthropic asked 132 engineers and researchers a series of very concrete questions:

How much of your daily work do you do with Claude?
What do you mainly use it for? Debugging, new features, refactoring, tests, documentation, or design and planning?
For each task type, does working with Claude make you spend more or less time?
Does the volume of output (code, docs, deliverables) go up or down?

They also compared changes over time:

A year ago, employees estimated that about 28% of their work used Claude, self-reporting a +20% productivity lift.
Now that number has risen to 59% of work done with Claude, with an average self-reported productivity +50%; around 14% of “power users” believe they improved by over 100%.

Another independent study is also striking: using 100,000 real conversations, Anthropic estimated that the median task completion time dropped by roughly 80%.

It sounds dramatic, but engineers know self-reported productivity needs a haircut. The more useful takeaway is: by task type, where are the real gains and where is the fluff?

II. Overall Pattern: Time Saved Is Small, Output Gain Is Big

That figure you saw is one of the core findings:

Left: after using Claude, for a given task, time spent goes down, stays the same, or goes up.
Right: in the same amount of time, the amount of output goes up by how much.

Looking across all tasks, two patterns stand out:

For most tasks, time is only slightly lower
- Many points sit around “-1” (a light decrease).
- It means people are saving a little, not cutting the time in half.
But the output increase is more obvious
- In the right plot, most points are in the “+1 to +2” range.
- So even when time only drops a bit, the amount produced jumps a lot.

A hidden detail: In the raw data, a small group actually spends more time on some tasks.

Their interview explanations feel very real:

Cleaning up after Claude—fixing the mess it made, redoing debugging and cleanup.
Spending time to understand code they did not write themselves.
Or because Claude exists, they simply work more thoroughly: more tests, more exploration.

In short:

Time does not vanish; it gets “reinvested” into more work.

III. ROI by Task Type: Frontend Wins, Design and Infra Lose

Looking at the distribution and my own experience, the ROI ranking is clear.

1) ROI Ceiling: Frontend, New Features, Debugging, Testing, Documentation

These tasks share traits:

Outcomes are easy to verify
- Frontend: run it and you immediately see if the UI is right.
- Debugging: reproduce the bug, run tests—pass or fail.
- Tests and docs: format and coverage are obvious at a glance.
Task boundaries are clear
- “Make this component responsive.”
- “Add a set of unit tests for this code.”
- “Write a README for new teammates.”

In these jobs, the most annoying part for humans is: mechanical, repetitive, boring to write, yet quality is visible instantly.

This matches a keyword Anthropic staff highlighted:

“I’m more willing to hand Claude tasks that are easy to verify.”

The report also notes that engineers increasingly use Claude for frontend visualization, implementing UI, and building small tools, even encouraging backend engineers to write frontend and become “quasi full stack.”

From an ROI lens, these tasks are short, fast projects:

Model does the work
Human reviews
If it breaks, roll back and redo
Beginners can supervise

Frontend is a clear beneficiary—screens, interactions, styles iterate quickly. You focus on user experience itself instead of wrestling with CSS details.

2) Lower ROI: Design and Planning, Infrastructure/DevOps

On the other end: high-level design, system planning, Infra/DevOps.

Anthropic’s report shows two things:

Employees explicitly said:
- “I usually keep high-level thinking and design to myself and hand implementation/debugging tasks to Claude.”
- Design and planning tasks show the smallest productivity lift.
Infra and DevOps tasks are used less often; time and output gains are limited.

This aligns with software-engineering common sense:

The more a task depends on experience, context, taste, and organizational strategy, the harder it is to fully hand it to AI.

Designing a new system architecture requires considering:

What the business looks like in five years
The team’s current stack
Who maintains it and who is on-call
Cost budget, compliance, and security

Claude can:

Generate versions of architecture diagrams
List risks and trade-offs
Draft design docs

But the person who approves is still you. Here AI is a smart adviser, not the decision-making CTO.

Infra/DevOps is similar:

The hard part is
- Knowing the company’s complex network topology
- Dealing with legacy scripts and configs
- Knowing who owns the pager when things break
AI can write scripts, explain logs, draft runbooks.
But it is hard to run a command to production without looking.

From an ROI angle:

Frontend, new features, debugging, testing, documentation -> low investment, fast return

Design, planning, Infra -> high value, but AI rarely “saves you a ton of time” directly

IV. Verifiability: The “Watershed” That Decides AI Effectiveness

In interviews, Anthropic summarized a pragmatic delegation rule: engineers are more willing to hand Claude tasks that are:

Easy to verify
Low complexity or clearly bounded
Not under extreme quality bars (e.g., one-off debug scripts)
Repetitive, dull, but cannot be skipped

This can be abstracted into one word: verifiability.

Think of it this way:

Tasks with tests or demos are great for AI to charge ahead
- Frontend pages, backend endpoints, data-processing scripts
- Run them and see whether the result is in the expected range
Tasks relying on “taste” and “judgment” need human oversight
- System design, UX design, security strategy
- Often no standard answers, only trade-offs
Local problems vs. global problems
- Changing one component or writing a doc is a local problem.
- Planning a cross-team technical roadmap is a global problem.

Claude delivers huge ROI on local, verifiable tasks. On global, fuzzy tasks, it is better for brainstorming, lists, and comparisons, not for directly giving the final plan.

V. Practical Tips for Typical Teams: Don’t Rush to Make AI the Architect

If you lead an engineering team or build solo, you can draw a clear “sphere of influence” for AI, following Anthropic’s approach.

1) Start by Treating AI as “Manual Labor + Recorder”

Let Claude handle:

Debugging
- Help locate stack traces, explain errors, reproduce bugs
- Write temporary scripts for validation
Tests, documentation, and comments
- Auto-complete unit tests, generate mocks
- Summarize PR changes, generate README and API docs
Frontend and visualization
- Produce page scaffolds and style options
- Build internal tools, dashboards, data visualizations
Small refactors and “paper cuts”
- Break a blob of code into functions
- Rename variables, extract shared logic

For these, just write clearer acceptance criteria. Results will beat asking it to “think up an architecture from scratch.”

2) Design and Planning: Use AI as a Brainstorming Partner

For high-level design, Claude works best when you:

Ask for multiple architecture options with pros/cons
Let it draft RFC/technical design first versions
Simulate reviews from different personas (e.g., “what would security ask?”)

Decision-making, trade-offs, and final sign-off stay with you.

3) Infra/DevOps: Scripts and Docs Can Be Delegated, Production Commands Are Yours

In Infra scenarios, it is safe to give AI:

Explanations of complex Kubernetes YAML or Terraform configs
CI/CD pipeline templates
Log reading and first-pass root-cause analysis

For commands or change plans that hit production, require:

A human to review again
A teammate’s review
A dry run in staging when needed

Set a simple team rule:

“Any command that directly affects production must be edited and executed by a human.”

4) Make Your Own “AI Task Map”

Following Anthropic, you can draw a table for the team:

Rows: Debug / Frontend / New features / Tests / Docs / Refactoring / Design / Infra …
Columns:
- Does AI draft it?
- Is AI allowed to finish it alone?
- Who reviews the final output?

This becomes your “AI usage policy.” Update it quarterly; when models upgrade, move more tasks into the AI column.

VI. The Future Engineer: More Full Stack, With Stronger Judgment

One survey insight resonated with me:

Employees estimated that 27% of Claude-assisted work would not exist without AI—extra refactors, dashboards, internal tools.

So Claude is not just speeding up existing work; it makes you do valuable things you “never had time for.”

At the same time, many worry:

With less time writing code, will my hands get rusty?
Supervising AI needs experience, yet experience is being eaten by AI.

This is the “oversight paradox”:

Using AI well requires strong judgment, and judgment itself needs hands-on practice.

A healthier approach might be:

Use AI boldly for high-ROI tasks.
Keep a portion of “handwritten training” for yourself.
Treat AI as an accelerator for your skill growth, not a substitute.

In the long run, what will engineers look like?

More like a mix of product + architecture + project manager + AI wrangler.
Focus more on “what to build” and “why,” rather than “exactly how this line of code looks.”

Conclusion: Use AI in the Right Places and Become the Team’s “Productivity Arbitrageur”

Anthropic’s internal survey points to a clear mindset:

Do not expect AI to 10x every task.
The real gap is whether you dare and know how to give it the right tasks.

If you are an engineer or tech lead, take a moment now to list your work:

Which tasks are easy to verify, repetitive and dull, and can be handed to Claude today?
Which tasks involve high-level design and team strategy—let it act as “think tank,” not “ghostwriter”?

Draw that “AI task map,” and your productivity in the team is already a big step ahead.

From Exploration to Fix: How Claude Code Thinks and Reasons Through a SQLAlchemy Transaction Rollback Issue

Oct 28, 2025

Vibe Sparking

This technical blog is distilled from a real production incident investigation. It focuses on how Claude Code “explores → thinks → reasons” to quickly pinpoint the root cause, ship the smallest viable fix, and propose follow‑up structural improvements.

The problem occurred in the mailflow service in production. The core error was:

This Session's transaction has been rolled back due to a previous exception during flush.
To begin a new transaction with this Session, first issue Session.rollback().
Original exception was: (sqlalchemy.exc.InvalidRequestError) Can't reconnect until invalid transaction is rolled back

From the surrounding logs, the failure happened when executing an INSERT into the emails table. Subsequent database operations then entered a “cascade failure” state.

1. Context and Goals

Context: While handling inbound emails (parsing, creating records, forwarding, moving IMAP folders), mailflow occasionally fails the entire processing chain.
Goals:
- Identify the primary trigger of the transaction failure;
- Explain why all subsequent DB operations report the same error;
- Restore processing with the smallest, lowest‑risk change;
- Provide structural improvement suggestions to increase robustness.

2. Exploration Path: From Symptoms to Evidence

Leveraging Claude Code’s code search and cross‑context capabilities, we proceeded “from symptoms to root cause” in order:

Locking onto logs and trigger point
- The logs show the exception stems from the SQLAlchemy Session state: after a prior transaction failure, rollback() was not performed, leaving the current Session invalid.
Locating key code paths
- mailflow/app/db.py: connection and session factory definitions.
- mailflow/app/mail.py: main business flow, record creation, and commit points.
- mailflow/app/utils.py: logging and WeCom notification entry notify_and_log.
Evidence 1: Module‑level global Session
- At the top of mail.py there is:
```
session = session_factory()  # module‑level global Session
```
- Once any flush/commit fails, this global Session becomes invalid, and all subsequent DB operations that rely on it will fail until an explicit session.rollback() is issued.
Evidence 2: Missing exception handling and rollback
- Multiple session.commit() calls lack try/except/rollback protection:
  - Creating the mail record (create_mail)
  - Relating attachments to mail (_relation_attachment_and_mail)
  - Updating status when dealing with request results (deal_requests_result)
  - Large sections of the main flow in process_mail

Conclusion: The first failed DB operation puts the global Session into an invalid state. Because rollback() is missing, all later commits and even queries on that path fail with the same error, forming a “cascade failure”.

3. Reasoning Chain: From Hypothesis to Verification

Hypothesis: An INSERT/UPDATE exception (possibly from data constraints, transient network issues, or the pool) invalidates the global Session; without rollback(), subsequent steps (status updates, attachment relations, mail moves) all fail.
Code verification:
- Found the global session = session_factory();
- Searched for session.commit() call sites — most lack except: session.rollback();
- This matches the error semantics exactly.
Strategy: Move fast with minimal change to restore stability first, then evaluate structural refactoring.

4. Fix Strategy and Implementation

We prioritized the fix in three levels (P0 → P2):

P0 (immediate, smallest change): add session.rollback() in exception handlers so the Session can self‑recover.
P1 (comprehensive guard): wrap every commit() with try/except/rollback to avoid any single failure taking down the rest of the flow.
P2 (structural): replace the module‑level global Session with scoped_session to isolate session state across processing flows (recommended, not mandatory for the hotfix).

4.1 Key Patch Snippets

Add rollback in the main flow (mailflow/app/mail.py)

try:
    # Parse, determine mail_type, build attachment parser, etc.
    ...
except Exception as err:
    session.rollback()  # Key: restore session state
    notify_and_log(...)
    process_status = False

Guard status updates when handling request results (wrap both success and failure branches)

try:
    mail.move_to = 'Done'
    mail.status = '20000'
    session.commit()
except Exception as err:
    session.rollback()
    notify_and_log(...)
    raise

Guard establishing mail–attachment relations

try:
    for item in a_list:
        attach = Attachment(...)
        session.add(attach)
    session.commit()
except Exception as err:
    session.rollback()
    notify_and_log(...)
    raise

Add protection for creating the mail record create_mail

try:
    mail = Email(...)
    session.add(mail)
    session.commit()
    return mail
except Exception as err:
    session.rollback()
    notify_and_log(...)
    raise

4.2 Structural Optimization (P2)

Eliminate the risk where a “global Session drags down all flows” by using scoped_session:

from sqlalchemy.orm import sessionmaker, scoped_session

session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)  # thread/coroutine‑local isolation

# Acquire/release at business entrypoints:
session = Session()
try:
    ...
finally:
    Session.remove()  # recycle the local session

Note: scoped_session provides better isolation in concurrent/multithreaded environments and reduces cross‑request contamination. The production hotfix first ensures rollback semantics are correct and complete; then evaluate the migration cost/benefit.

5. Validation and Regression

Suggested validation steps:

Single reproducible mail replay: replay a previously failing mail and observe whether the chain recovers;
Observe logs: the message “Can’t reconnect until invalid transaction is rolled back” should no longer appear;
Manual spot‑check: verify IMAP folder moves, forwarding, and database state;
Controlled load: increase the number of sample mails to ensure multiple commit points correctly roll back and continue.

6. Lessons Learned and Best Practices

Anti‑pattern: a module‑level global Session, once invalid, causes chain‑wide cascade failures.
Principle: every commit() should be wrapped by try/except + rollback; also rollback() in the top‑level exception handler of the main flow.
Design: adopt a failure‑resilient session model (scoped_session or acquire/release per processing unit).
Operations: log and alert immediately (this project uses WeCom via notify_and_log), and include key identifiers (uid, subject, time, to_list) in the message.

7. Claude Code’s Methodology

This “explore → reason → fix” path generalizes to most code‑level issues:

Quickly bound the problem: start from the error semantics and match the most likely layer (transaction/session management).
Evidence‑driven search: find the relevant files, variables, and functions (session_factory, commit() call sites).
Hypothesize → falsify/corroborate: propose “global Session + no rollback → cascade failure”, then find direct evidence in code.
Smallest change first: add rollback() so the Session can recover and stop the bleeding.
Structural improvement: propose scoped_session as the follow‑up path, balancing benefit and migration cost.

Let Claude Skills Be Your Power‑Up: 3‑Step Quickstart, Highlights, and 8 Real‑World Scenarios

Oct 18, 2025

Vibe Sparking

Have you had this moment? You grind on reports like brick‑laying or pull all‑nighters on slides, but a teammate seems to have a cheat code—one prompt and they ship a brand‑compliant pack. The newly released Claude Skills is how to install that “cheat” into Claude. It wraps repetitive work into modules that auto‑match and auto‑run—like “expertise packs” on demand.

What are Claude Skills? (one‑liner)

One folder = one skill. Inside are instructions (SKILL.md), scripts, and resources. Claude auto‑loads and uses the skill for fitting tasks. You don’t need to code to turn your work patterns into reusable skills.

Quick highlights – Auto trigger: semantic matching to the right skill – Composable: multiple skills can collaborate – Code execution: run scripts when needed, stable and reproducible – Works everywhere: Claude.ai, Claude Code, and API – Enterprise‑ready: brand rules, compliance checks, spreadsheet automation

How it “automates”: 5 moments from discovery to collaboration

Scan & discover: on start, Claude scans available skills and reads short summaries (minimal context budget).
Match: when you ask, Claude checks whether a skill fits.
Activate: if matched, it loads the skill’s instructions/resources/scripts.
Execute: follows instructions and runs code tools when needed.
Collaborate: skills can run in parallel or in sequence.

Three steps to install & use (2‑minute lift‑off)

A. Install Claude Code (optional but recommended)

npm install -g @anthropic-ai/claude-code

B. Enable Skills in Claude / Claude Code Turn on Code execution / File creation in settings, then enable Skills or upload a ZIP (for custom skills).

C. Create a custom skill (minimal structure)

Create folder my-skill/
Write SKILL.md: YAML header with name and description; body with steps and constraints; add resources/ or scripts if needed.
Place it in your user or project area (e.g., .claude/skills or project/claude/skills) so Claude can discover it.

Want to start fast? Grab official/community examples and tweak.

A starter template (copy‑ready)

SKILL.md snippet (example):

---
name: Branded PPT Maker
description: Convert an outline to a PPT with our brand fonts, colors, and slide layout rules.
allowed-tools:
  - python:read-only
  - bash:read-only
---
# Instructions
- Read /resources/brand-guidelines.pdf
- Use title/body styles from page 5
- Build slide outline from user's bullets
- Export as .pptx

Key idea: write human‑readable triggers, boundaries, inputs/outputs. Throw brand guides, templates, and examples into resources/. Add scripts for stable steps.

Work scenarios: 4 “this saves absurd time” uses

1) One‑click Excel reports

Feed templates + rules. Auto formulas, pivot tables, and chart palettes. Weekly reviews in 10 minutes.

2) Brand‑consistent PPT factory

Give brand guides and master slides. The skill applies layout, character counts, and alignment—and can output a presenter script.

3) Web app smoke tests

Put cases and selectors in resources; scripts click/assert and the skill returns a screenshot report.

4) Compliance/legal clause checks

Load policies and banned‑term lists; the skill flags risky sentences and suggests rewrites.

Life scenarios: 4 “you’ll keep using it” ideas

1) Trip planning + budget sheet

Provide city, days, and preferences. The skill builds itinerary, routes, and budget—and exports an Excel breakdown.

2) Fitness + meal plans

Encode goals and allergens in SKILL.md. The skill returns a weekly meal plan and shopping list.

3) Household bill reconciliation & split

Import utility CSVs. The skill categorizes, fixes errors, visualizes, and outputs who pays what.

4) Family/friends event organizing

Bundle a template + checklists. The skill generates the group announcement, sign‑in sheet, and supplies list.

FAQs

Security? Only enable trusted skills; code‑executing skills run sandboxed with permissions.
Who gets it? Pro, Max, Team, Enterprise—available on Claude.ai, Claude Code, and API.
Where to find examples? Start with official/community repos—adapt a close match.

Closing

In short, Claude Skills productize your workflow. Package experience, rules, and templates into triggerable, reusable, and composable skills. Install a “report skill” today, add a “brand skill” tomorrow—and your AI really will learn your way of working.

Which task would you skill‑ify first? Share in the comments.

Build an Efficient, Lightweight, and Controlled Spec‑Driven Workflow with OpenSpec + Claude Code

Oct 17, 2025

Vibe Sparking

When teams start collaborating with AI coding assistants, clearly answering “what to build, how to build it, and how we know it’s done” becomes crucial. This guide walks you through a practical, reviewable, and traceable development workflow using OpenSpec (documentation‑driven development) together with Claude Code (an intelligent coding assistant).

Who this is for:

Teams that want specs before changes in multi‑person collaboration
People/teams that want AI assistants embedded into a standard workflow
Projects that require approval, archiving, or compliance control

Core Principles — Specs Are Truth

Specs are truth: openspec/specs represents the currently delivered source of truth.
Propose before changes: any change impacting behavior/architecture/security/performance starts in changes/[id].
Three‑phase loop: Create change → Implement tasks → Archive and codify.
AI works to specs: Claude Code always uses OpenSpec as the authoritative context.

Install and Initialize

Install OpenSpec (global):

npm install -g @fission-ai/openspec@latest

openspec --version

Initialize at the project root:

openspec init

Initialization will:

Write a cross‑assistant AGENTS guide at the repo root
Generate the openspec/ directory structure
Establish unified collaboration instructions for Claude Code / Cursor / Codex, etc.
Later you can run openspec update to refresh the guidelines

Recommended directory structure (auto‑generated):

openspec/
├── project.md              # Project conventions, background, stack
├── specs/                  # Delivered capabilities (source of truth)
│   └── [capability]/
│       ├── spec.md         # Requirements + scenarios (canonical format)
│       └── design.md       # Technical approach (optional)
├── changes/                # Proposals (pending changes)
│   ├── [change-id]/
│   │   ├── proposal.md     # Why / What / Impact
│   │   ├── tasks.md        # Implementation checklist
│   │   ├── design.md       # For large changes
│   │   └── specs/          # Delta for affected capabilities
│   │       └── [capability]/spec.md
│   └── archive/            # Archived changes

Collaborating with Claude Code

OpenSpec provides project context and process standards; Claude Code executes the Read → Generate → Implement → Verify cycle. After initialization, start your Claude Code session with prompts like these:

Fill in project context:

Please read openspec/project.md. Based on the repo’s current state, help me fully document project goals, tech stack, conventions, external dependencies, constraints, and naming standards.

Create the first change proposal:

I want to add “[your feature]”. Please create an OpenSpec change proposal (changes/[id]/) including proposal.md, tasks.md, and the relevant specs delta under changes/[id]/specs/.

Explain/enforce the workflow:

Using openspec/AGENTS.md, explain the three‑phase workflow and strictly follow it in subsequent steps: propose and validate first, implement after approval, archive when complete.

Tip: After installation, Codex/Windsurf/Cursor, etc. will also pick up the same guidelines so multiple assistants collaborate consistently.

Three‑Phase Workflow (from `openspec/AGENTS.md`)

Create Change

When: new capability, breaking change, architecture/security/performance strategy changes
Steps:
- Pick a unique change-id (kebab‑case, verb‑prefixed: add-, update-, remove-, refactor-)
- Generate proposal.md, tasks.md, and design.md if needed
- Write specs delta using operation headers: ## ADDED|MODIFIED|REMOVED|RENAMED Requirements
- Validate: openspec validate <id> --strict
- Only implement after approval

Implement Change

Steps:
- Read in order: proposal.md → design.md (optional) → tasks.md
- Implement strictly in tasks.md order; check off each item when complete
- Update overall task status only when all are completed

Archive Change

After deployment:
- Move changes/[id] to changes/archive/YYYY-MM-DD-[id]/
- If capability behavior changed, update openspec/specs/
- Run strict validation: openspec validate --strict
- Optional: openspec archive [change] [--yes|-y] to auto‑archive (tooling changes may use --skip-specs)

Key Spec File Format (Important)

Each requirement uses ### Requirement: ...
Each requirement must have at least one scenario using a level‑4 heading:

#### Scenario: Returns success
- **WHEN** input is valid
- **THEN** return 200 with data

Do not use bullets or bold text instead of a scenario heading (the parser will fail).

Three types of delta changes:
- ## ADDED Requirements for new capabilities
- ## MODIFIED Requirements for behavior changes (paste the full updated requirement block, not a diff)
- ## REMOVED Requirements for removals (include rationale and migration)
- ## RENAMED Requirements for renames only

From Zero to One: A Happy Path

Explore current state

openspec spec list --long
openspec list

# Full‑text search via ripgrep is also recommended:
rg -n "Requirement:|Scenario:" openspec/specs

Choose a change ID and scaffold

# Example: add-direct-youtube-subtitle-download
# You can also ask Claude Code to create the directory and file skeletons for you

Write the delta (example)

## ADDED Requirements
### Requirement: Direct subtitle download
The system SHALL request subtitle files directly from YouTube without relying on M3U8.

#### Scenario: Download succeeds
- **WHEN** a valid video and subtitle language are provided
- **THEN** download the corresponding subtitles and save to the target directory

Strict validation

openspec validate add-direct-youtube-subtitle-download --strict

Approval → Implementation

openspec apply add-direct-youtube-subtitle-download

After approval, have Claude Code implement items in tasks.md step by step
Check off one item when it’s done; proceed until all are - [x]

Archive and codify

openspec archive add-direct-youtube-subtitle-download --yes
openspec validate --strict

Best Practices with Claude Code

Always let Claude Code “read” first: openspec/project.md, relevant specs/[capability]/spec.md, and changes/[id]/proposal.md|tasks.md
Execute strictly against tasks.md as the single source of truth; check off as you go
Prioritize edits directly related to the proposed change; avoid unrelated refactors
When ambiguous, ask 1–2 clarifying questions before scaffolding
When referencing code locations, use src/module.ts:42 single‑line pointers
Built‑in validation: openspec validate [change] --strict; if issues occur, use --json to diagnose

CLI Cheat Sheet

List / show / diff / validate

openspec list
openspec list --specs
openspec show [item]              # change or spec
openspec diff [change]
openspec validate [item] --strict

# Init / update
openspec init [path]
openspec update [path]

# Archive (post‑deploy)
openspec archive [change] [--yes|-y]

Common flags:

--json machine‑readable output
--type change|spec to specify the object type
--strict strict validation
--skip-specs archive only (skip specs update)
--yes|-y skip confirmation (good for CI)

Proposal vs. Direct Fix — When to Use Which?

Propose (recommended) when:

New features/capabilities
Breaking changes (API/Schema)
Architecture/pattern shifts
Performance/security strategy changes that affect behavior

Direct edits are fine when:

Bug fixes (restoring intended behavior)
Copy/format/comments
Non‑breaking dependency upgrades
Minor configuration tweaks
Tests that cover existing behavior

Common Pitfalls and Troubleshooting

“Change must have at least one delta”
- Check that changes/[id]/specs/ contains .md files
- Ensure files include ## ADDED|MODIFIED|REMOVED operation headers
“Requirement must have at least one scenario”
- Scenario headings must be #### Scenario: ... (level‑4 heading)
- Do not use bullets or bold text
Delta parsing failures
- Use openspec show [change] --json --deltas-only to debug
- Compare with originals under openspec/specs/ and ensure MODIFIED is a full replacement block

Conclusion

Use OpenSpec to make Requirements → Design → Tasks → Changes explicit from day one and treat them as the project’s source of truth. Then leverage Claude Code for efficient execution and collaboration so AI delivers within clear boundaries. The benefits:

Specs first to reduce rework; approvals up front to lower risk
Task closure with traceable outputs; archivable changes for reusable knowledge

Claude Code 2.0.17 Update: Haiku 4.5 Takes Execution, Plan with Sonnet — Faster and Cheaper

Oct 16, 2025

Vibe Sparking

Introduction

Today’s update is very kind to developers who code with Claude Code.

Claude Haiku 4.5 launches — cheaper and faster; Plan mode defaults to Sonnet for planning and switches to Haiku for execution. In practice, projects run smoother and your wallet hurts less. Official pricing/positioning and how this release hooks into Claude Code both support that conclusion.

Highlight 1: Lower cost, faster speed

Haiku 4.5: $1 / $5 (input/output per million tokens) — aimed at real‑time, low‑latency work, with optimizations for coding, sub‑agent collaboration, and computer‑use scenarios. Compared with Sonnet 4 from May, it’s well over 2× faster at about one‑third the cost, while delivering “near‑frontier” performance on many coding tasks.

Why “more economical”? Compare peers on pricing:

Sonnet 4.5: $3 / $15 (input/output).
Opus 4.1: $15 / $75 (input/output).

This means you can hand off execution steps that don’t need the “strongest brainpower” to Haiku 4.5. Bills slim down immediately and responses feel snappier. If you run many agents, hit backend services, or trigger calls frequently from your IDE, the value is obvious.

Summary: Haiku 4.5 = coding ability close to Sonnet 4 + faster speed + one‑third the price. It’s not a “make‑do small model”, it’s a “deployment‑grade workhorse”.

Highlight 2: Plan with Sonnet, execute with Haiku (the 2.0.17 default pairing)

In Claude Code 2.0.17, a crucial detail: Plan mode uses Sonnet by default for planning, then automatically switches to Haiku for execution. That mirrors real workflows in the terminal/VS Code: deep reasoning with Sonnet, batch implementation with Haiku.

Version signal: the VS Code extension is now 2.0.17, released with the October update.
Official framing: Sonnet 4.5 remains the primary engine behind Claude Code, handling long tasks and complex planning; Haiku 4.5 fills the execution seat with more speed and lower cost.

This plan/execute layering follows the familiar pattern of “frontline model for Plan, next‑tier model for implementation” — except now Haiku 4.5 takes the more capable spot on the execution side.

Real‑world take: Opus is phenomenal (and pricey); Sonnet is steady; Haiku now carries

After several large runs, here’s the blunt take:

Opus: expansive ideation, cross‑stack architecture, deep retrieval — rock‑solid. But the bill is hard to stomach. If you also hand it execution, you get great results and a racing heartbeat.
Sonnet 4.5: currently the most usable “coding brain” in the Claude family. In Plan mode it thinks clearly: strategy, steps, and risk flags are all there.
Haiku 4.5: the MVP for execution. Running agent subtasks, fanning out in parallel, scaffolding, moving files, getting tests green — it’s fast and frugal. For front‑end scaffolds, mass renames, fixture generation, it barely “breaks a sweat”.

In short: Use Sonnet for expensive “thinking”; give Haiku the bulk “hands‑on”. Your speed goes up, costs come down, and stability is easier to control.

Getting started (for busy engineering teams)

Keep the Plan→Exec split: clarify the hard parts, then dispatch subtasks in parallel; let Haiku 4.5 handle execution.
Lean on parallelism and sub‑agents: spin up multiple Haiku 4.5 workers; coordinate with a Sonnet 4.5 orchestrator.
Make costs visible: track API usage, measure call shares across Haiku/Sonnet/Opus, and review a sprint‑length invoice.
Match model to scenario: real‑time assistants, support tickets, low‑latency orchestration → favor Haiku 4.5; complex refactors and multi‑repo surgery → Plan with Sonnet 4.5.

Conclusion

No flashy tricks here — this update makes “useful + economical” a daily development default. Plan with Sonnet, execute with Haiku. Code moves fast and spending is transparent.

What’s your take? Which tasks see immediate gains with Haiku 4.5? Share real‑world results in the comments.

Break the “etc.”: Clarity for Claude Code

Oct 16, 2025

Vibe Sparking

One‑line takeaway: AI coding speed can’t fix fuzzy specs. To make Claude Code truly low‑friction, break every “etc.” into a checklist, turn acceptance into an executable script, and let automation run the tests.

Introduction

Have you ever written a requirement like: “Show key device info on the home page (power, volume, etc.).”

Then at QA time, the AI only implements the first three. The “etc.” simply disappears. It’s not that the AI isn’t smart; the signal you gave wasn’t precise. Claude Code “does less” when your instructions are vague—it will reasonably but incompletely narrow the scope. That’s not a bug; it’s a boundary reminder for human‑AI collaboration.

By the way, Anthropic just bumped Haiku to 4.5: cheaper, faster, and coding performance close to Sonnet (now available in Copilot too). It’s faster, yes—but it still won’t auto‑complete your “etc.”

What you see: the less you write before “=”, the less you get after it

You wrote “power, volume, brightness, etc.”
Claude Code reads this as three explicit items + one implicit “etc.”
Result: code, automated tests, and docs all cover only the first three

It’s not AI “cutting corners.” It’s AI prioritizing what’s verifiable. Explicit items can produce code and tests; ambiguous ones get skipped. This shows up repeatedly in research and industry reports—with incomplete or vague specs, AI helpers are more likely to miss features, even when they produce code faster.

A copy‑and‑use solution: don’t let “etc.” ship to production

This workflow works for any app, admin, or web project. Steal it.

1) Turn every “etc.” into a data‑driven checklist

Write the nouns as a table and add “status, source, display rules, empty‑state policy, error policy” for each item. Example fields:

Name: Power / Volume / Brightness …
Domain: On/Off; 0–100 …
Source: local cache / backend API / Bluetooth …
Display: icon, label, unit
Empty: show “—” or greyed out
Error: timeout, disconnect, permission‑denied placeholders

The payoff: AI can generate complete UI + validation + empty states + error handling, not just “three components that look right.”

Tip: Use Gherkin/BDD for acceptance, and write behavior as a Given‑When‑Then script. Human‑readable, machine‑testable.

2) Upgrade acceptance from “verbal agreement” to “executable”

Convert the checklist into Gherkin scenarios, then have AI generate the automation (e.g., Cypress/Playwright):

Feature: Device key info panel
  Scenario Outline: Render each key info item
    Given the device exposes "<name>" with value "<value>"
    When I open the home page
    Then I should see "<label>" and formatted "<value>"

    Examples:
      | name       | value | label       |
      | Power      | On    | Power       |
      | Volume     | 70    | Volume      |
      | Brightness | 40    | Brightness  |
      | …          | …     | …           |

Research shows: generating Gherkin from user stories first, then turning it into executable tests (Cypress, etc.) significantly improves coverage and control.

3) Put reuse in the data layer to avoid re‑implementing the same thing

Don’t write multiple near‑duplicate infos() scattered across modules. Extract a reusable data mapping and renderer: one schema, consumed everywhere.

keyInfo.schema.ts: fields, domain, formatters, empty‑state policy
keyInfo.adapter.ts: unify sources (API, Bluetooth, cache)
KeyInfoPanel.tsx: pure presentation, no business logic
keyInfo.spec.ts: table‑driven tests; add one schema item = get more tests for free

Result: when you later add “battery temperature,” you just update the schema and everything else follows. That’s engineering the “etc.”

4) Put “AI‑generated” into CI

On PRs, automatically run: type checks, static rules, unit + acceptance tests.
Gate: if checklist count ≠ test‑covered count, reject the merge.
Add security and compliance scans to prevent AI‑introduced latent risks.

Unit tests tell you “what broke.” Acceptance tests tell you “is it actually complete.” You need both.

5) Use Claude Code’s latest features—just don’t expect mind‑reading

Claude Code Plugins: bundle “checklist generation → Gherkin → test coverage checks” into an installable workflow your team can share.
Haiku 4.5: cheap and fast, perfect for mass‑producing the “checklist → scenarios → tests” grunt work. Rolling out in Copilot too.
Remember: faster ≠ understands you better. Clarity is the true force multiplier.

Quick checklist (paste into your team wiki)

Shared definitions

Break every “etc.” into a tabular checklist with domain, source, display, empty, and error policies.
Write one Gherkin scenario per item.

Automation

Use Claude to generate Cypress/Playwright scripts.
CI rule: checklist count = passed scenario count.

Engineering reuse

schema + adapter + pure UI component.
New item = update schema; tests and UI follow automatically.

Security & quality

Static analysis + dependency/secret checks.
No merge if gates fail.

Conclusion

Claude Code isn’t slacking. It follows the boundaries you set. When you turn ambiguity into structure and acceptance into execution, AI becomes a reliable teammate.

Where does your team most often write “etc.”? How are you addressing it? Share in the comments.

Ship a Rails feature in minutes with Claude Code: Document‑Driven dev + RSpec BDD

Oct 16, 2025

Vibe Sparking

Introduction

Ever felt this pain? A device reports multiple states within a minute and your database turns into a wall of “noise”.

Here’s a general, reusable practice: in Rails, merge repeated reports that arrive within a short, configurable time window into a single “golden record”.

I’ll use Claude Code with a document‑driven approach: start from a single page of specs → generate BDD scenarios → validate with RSpec → minimal implementation → write findings back to the doc. The loop is fast, stable, and traceable. If you’re new to Claude Code, the official docs outline a clear playbook and best practices.

Our “public version” requirement (desensitized)

Business context (generic)

An “intelligent fitness band” may report multiple heart‑rate/status events within one minute. To avoid redundancy, we want to:

Within a configurable time window (default 1 minute), grouped by device and type, merge multiple events into one;
Keep the latest record within the window (i.e., the last one wins);
Write to a unified work record table, ensure idempotency, and keep merge provenance for audit and traceability.

Document‑Driven

Put the above into a single “feature spec” document. That document doubles as the product contract and acceptance criteria. From it, we derive BDD scenarios and tests. This follows the same spirit as “Specification by Example/ATDD/BDD”: examples are the single source of truth.

Claude Code + BDD: from doc to executable acceptance

Why Claude Code

It’s a terminal‑native coding copilot that actively pulls context. It connects code, docs, dependencies, and scaffolding, turning ideas into runnable structure quickly. The docs include hands‑on tips such as how to organize repositories so the agent “understands” your intent.

Prompt template (paste into Claude Code)

Role: Senior Rails engineer + test coach Goal: Implement “device report merge” as a reusable capability Deliverables:

Based on the spec below, generate RSpec BDD scenarios and edge cases (Rails + Capybara/request/service layer);

Provide a minimal implementation skeleton (service object, queries, transaction, idempotency strategy);

Propose rollback and audit logging;

Write all assumptions back to the doc under “Open Questions”. Attachment: the feature spec (paste the “public version” requirement above)

Why RSpec + BDD

RSpec reads like behavior. Tests are documentation. Rails’ official guide also clarifies test layers. With Capybara/request specs you can do API acceptance and system flows.

Acceptance examples (trimmed BDD thinking)

User story

As a data platform, within one minute, multiple reports of the same device and record type should be merged into one, taking the last record as the truth. This keeps queries clean and metrics correct.

Key scenarios

In‑window merge: t=00:10 and 00:40 → save 1 row, payload from 00:40.
Cross‑window no‑merge: t=00:10 and 01:15 → save 2 rows.
Idempotent writes: repeated requests do not produce duplicate merge results.
Auditable: keep source IDs and window parameters.

Tip: Put these examples in the doc/feature file so they serve both discussion and automated tests.

RSpec skeleton (snippet)

RSpec.describe RecordMerger do
  let(:device_id) { "device-123" }
  let(:window)    { 1.minute }

  it "merges multiple records within window, keeps the latest" do
    create(:work_status, device_id:, recorded_at: Time.current - 40.seconds, payload: { hr: 85 })
    create(:work_status, device_id:, recorded_at: Time.current - 10.seconds, payload: { hr: 92 })

    result = described_class.call(device_id:, record_type: :work_status, window:)

    expect(result.payload[:hr]).to eq(92)
    expect(WorkStatus.where(device_id:).count).to eq(1)
  end

  it "does not merge across windows" do
    create(:work_status, device_id:, recorded_at: Time.current - 75.seconds)
    create(:work_status, device_id:, recorded_at: Time.current - 10.seconds)

    described_class.call(device_id:, record_type: :work_status, window:)

    expect(WorkStatus.where(device_id:).count).to eq(2)
  end
end

Reference: See RSpec/Capybara conventions for feature tests and dependency constraints.

Rails minimal implementation (map)

Entry point: service object RecordMerger.call(device_id:, record_type:, window:)
Query: same device + same type + recorded_at within the “natural time window”
Merge strategy:
- Use the record with the max recorded_at as the base data
- Persist the rest as the provenance set, e.g., merged_from: [ids...]
Idempotency & concurrency:
- App‑level mutual exclusion by device + window (e.g., with_advisory_lock)
- Unique index on the critical key (device + window start, or a computed idempotency key)
Audit:
- Record merge_window_sec, merged_count, merged_from
- Emit event logs for tracing and replay

For broader coverage, add request/system tests to verify API I/O. Rails’ testing guide explains test responsibilities across layers.

Make AI truly accelerate: engineering checklist

Keep the spec in the repo root with a consistent name so Claude Code can auto‑pull context.
Advance one micro‑goal at a time: get “in‑window merge” green first, then expand to idempotency and audit.
Write back to the doc frequently: new edge cases, pitfalls, and decisions go to “Open Questions/Decision Log”.
Backups and milestones: long sessions may compress context—split sessions at milestones, tag them, and keep local snapshots. AI is a power tool; you are still the craftsperson.

Industry feedback echoes this: Claude Code is rolling out across teams, long‑context models keep improving, and large‑repo analysis is getting steadier.

What the deliverables look like (team template)

One‑page feature spec (background, goal, scope, glossary, examples, open questions)
RSpec suite (service + request/system tests, with edges and regression)
Service object + indexes/locks (minimal viable)
Event log + dashboards (merge hit rate, storage saved, query latency deltas)

Value is measurable: docs are the contract; tests are the acceptance; logs are the operational review.

Iteration stays smooth: adding a “2‑minute window” or “window per type” is just add examples → run tests → small tweaks.

Conclusion

Document‑Driven + BDD does not mean “write more docs”; it means making the doc an executable product contract. With Claude Code, you compress the chain from idea → tests → implementation → review to hours. Collaboration gets smoother, delivery more stable, and reading the code feels like reading a story.

How would you land this merge capability in your team? Any stronger idempotency key designs? Share in the comments.

One Prompt, Three Stacks: Shipping Session Auto‑Lock with Claude Code

Oct 15, 2025

Vibe Sparking

Write an absurdly short prompt and the agent patches Web (TypeScript), App (Flutter), and API (Rails) in one go: adds the feature, wires permissions, localizes strings, and even creates migrations and runs checks. The best part: easy to write, easy to reuse.

Sounds unbelievable? Read on.

Why this approach works now

Claude Code has plugins: slash commands, sub‑agents, MCP servers, and lifecycle hooks bundled into installable units. Teams can turn cross‑stack edits into a standard pipeline.
MCP (Model Context Protocol) is like giving AI a USB‑C port: plug IDEs/agents into your repos, databases, and tools with structured read/write and execution.
Remote MCP is supported: connect to cloud services with auth; in enterprise multi‑repo/multi‑environment setups it’s much simpler.
Official best practices for agentic coding emphasize structured goals and checklist‑style requirements, making outcomes more reliable.
New models and ecosystem momentum help. Sonnet 4.5 is stronger for complex agents and “computer use” scenarios; paired with plugins/MCP it makes the path from prompt to patch much smoother.

—

A stand‑in scenario: Session Auto‑Lock Duration

We’re adding a new item under Security Settings: Session Auto‑Lock (Duration).

Two options: Standard (2 minutes) and Strict (30 seconds)
Only authorized users can view/modify
Web Admin, App Settings, and API change together
i18n in English and Chinese

This feature is generic enough and avoids any sensitive business logic.

—

A structured prompt for Claude Code (drop‑in)

Treat the following as a “work order”: short sentences, imperative verbs, 2–4 lines per block. Fewer back‑and‑forth questions, more results.

Task: Add "Session Auto-Lock Duration" to Security Settings across Web (TypeScript), App (Flutter), and API (Rails).

Context:
- Two options: standard=2 minutes, strict=30 seconds. Default=standard.
- Only authorized users can view/modify this setting.

Requirements:
1) Web Admin:
   - Add a dropdown field under Security Settings.
   - Options: Standard / Strict. Bind permission key: session_auto_lock.
   - Localize: en_US, zh_CN.

2) Mobile App:
   - Add the same dropdown in Security Settings screen.
   - Read/write to user/device security config. Hide/disable if unauthorized.
   - Localize: en_US, zh_CN.

3) API:
   - DB migration: add string column "session_auto_lock_duration" with default "standard".
   - Model enum: STANDARD/STRICT/ALL_OPTIONS.
   - Permission registration for "session_auto_lock".
   - Validation: only allow ALL_OPTIONS; return 403 if unauthorized.

4) Copy:
   - en_US: "Standard: 2 minutes", "Strict: 30 seconds"
   - zh_CN: "标准（2分钟）", "严格（30秒）"

5) Review checklist:
   - Permission gating works in Web/App/API.
   - Default renders as "standard".
   - i18n strings appear correctly.
   - Ship diffs per repo with tests passing.

This “clear landing points + checklisted requirements” style works best for agentic coding. Claude Code also recommends structured instructions to reduce iteration.

—

What changes look like across the three stacks

Web (TypeScript)

Add a Session Auto‑Lock dropdown under Security Settings.
Bind permission key session_auto_lock; hide or disable if unauthorized.
i18n:
- en_US: Standard / Strict
- zh_CN: 标准（2分钟）/ 严格（30秒）

App (Flutter)

Add the same dropdown on the Security page.
Read/write to the security configuration; disable or hide if unauthorized.
Copy matches Web for consistency.

API (Rails)

Migration: session_auto_lock_duration, default standard.
Model constants: STANDARD / STRICT / ALL_OPTIONS.
Permission registration: session_auto_lock; whitelist validation on write; 403 if unauthorized.

These steps can be chained via plugins + MCP: the agent reads/writes across repos, generates migrations, runs tests, and opens PRs.

—

How teams operationalize it

Preparation

For Web/App/API, wire up a lightweight agent or expose the sequence as a plugin command.
Connect local/remote MCP; bind repos and CI.

Execution

Trigger with the “work‑order‑style” prompt above.
The agent produces patches, migrations, i18n, and permission registration; then opens MR/PR.

Review

CI runs Lint/Tests; failures go back to the agent for fixes.
Humans review only key diffs and acceptance criteria.
Need compliance/auditing? Add operation logging and rollback scripts to the plugin.
- Note: tooling is increasingly focused on governance and safety; agent platforms are improving policy and usage controls.

—

Pitfalls and tips

Don’t write scattered instructions. Short imperative sentences with concrete targets work best.
Hard‑code the permission keys, defaults, and whitelist options; don’t leave them to model “creativity”.
Provide the final copy strings up front to avoid another round trip.
Remote MCP is great, but enforce authentication and least privilege; separate environments and roles.
Save this prompt in the team’s instruction library/plugin. Next time you only swap the “feature name + enum options”.

—

Closing

Let standards handle the complex parts, and humans keep the simple parts. With one structured prompt + pluginized agent + MCP, you can flatten the “cross‑stack, cross‑repo, cross‑language” busywork. You focus on defining the requirement and making the final call; let the machine run the rest.

What do you think? Would this Session Auto‑Lock approach fit your project?

Triple Your HarmonyOS App Development Speed with Claude Code + Documentation-Driven Programming + BDD Business-Driven Testing

Sep 26, 2025

Vibe Sparking

This methodology specifically addresses three major pain points: “AI can write code but doesn’t understand HarmonyOS,” “ArkTS keeps throwing errors,” and “regression testing can’t keep up.” The core principle: Drive Claude Code with documentation, and secure quality through BDD automation.

Introduction: Don’t Chat Randomly with AI – Write Good Documentation First

Many developers immediately tell AI: “Help me build a HarmonyOS app for Bluetooth scanning, connecting, and time synchronization.” The result? Claude Code produces seemingly sophisticated code that turns completely red upon compilation. Are you familiar with ArkTS? Do you understand the ArkUI lifecycle? How do you handle regression testing? All uncertain.

HarmonyOS officially provides ArkTS coding standards, ArkUI declarative development paradigms, and performance practices – these are standard components that Claude Code “crashes repeatedly if not learned properly.” ArkTS is HarmonyOS’s primary language, sharing roots with TypeScript but having its own semantics and ecosystem. Writing with old JavaScript habits makes it easy to fall into traps. The good news is: Claude Code already supports “reading repositories, editing files, writing and running tests, executing terminal commands.” As long as you provide the right context, it can consistently produce engineered results.

I. Documentation-Driven Programming: Make Claude Code Follow Your Lead

Objective: Clearly explain requirements, value, implementation, and acceptance criteria on one page; let Claude Code “build according to specifications” within the HarmonyOS context.

1) Write “One-Page” Requirements (can be directly placed in repository `/docs/feature-xxx.md`)

Functionality: Bluetooth device scanning → list display → connection → time synchronization → status reading → command sending → disconnection
Business Value: Store associates complete device initialization in 1 minute, reducing manual errors by 80%
Platform: HarmonyOS NEXT, ArkTS + ArkUI; DevEco Studio build
Interface/Model: Device names start with XX; display battery level after connection; “injection” command returns success flag
Acceptance Criteria (BDD format):
- Given Application is on the home page
- When Click “Start Scan”, see device starting with XX in list and click Connect
- Then Enter connected page, see device name/battery level; clicking “Sync Time,” “Refresh Status,” “Send Injection Command” all return success

Remember to include key ArkTS/ArkUI constraints and best practices in documentation: naming, state management, performance considerations, etc. (from official style guides and state management guidelines). Provide specifications directly to Claude Code – it will follow these rules during generation.

2) Initial System Prompt for Claude Code (place in `.claude/primer.md`)

Project framework (ArkUI page structure, directory conventions)
ArkTS code style requirements (variable/component naming, null checks, error handling)
Component inventory & event flow (Button → scanning → list → connection)
Test-first approach: Generate BDD scenarios and ArkTS test stubs first, then supplement business code
Failure retry: compilation error → read error → modify minimal set only

Officials and community both emphasize standards-driven coding, which significantly reduces rework and performance issues. Claude Code itself also recommends customizing context and environment (e.g., ignoring irrelevant files, providing dedicated README/CONTRIBUTING), which can significantly improve hit rates.

3) Place “Process Description + Acceptance Steps” in README

The image below shows our manual acceptance steps for this feature, used for manual verification and providing context for Claude Code:

Index/Connected Manual Acceptance Instructions

This text will be absorbed by Claude Code as “executable documentation”: it can write UI flows first, then supplement logic and tests (Claude officially claims to “write and run tests, edit files, commit code”).

II. BDD Business-Driven Testing: Transform “Documentation” into “Executable Specifications”

In one sentence: Write requirements as Gherkin scenarios, run tests on DevEco/arkXtest framework, test red → AI fix → test green again.

1) Describe Business with Gherkin

Feature: Scan and connect device
  Scenario: Find and connect device with prefix XX
    Given App on Index Page
    When I tap "Start Scan"
    Then I should see a device starting with "XX" in the list
    When I tap "Connect" on that device
    Then I should be on Connected Page with name and battery shown

The advantage of Gherkin/BDD is transforming “business language” directly into executable specifications, continuously validating whether system behavior matches documentation.

2) ArkTS Testing Implementation Selection

DevEco/arkXtest System: Provides unified framework for unit testing + UI testing + performance testing; UI test scripts execute on top of unit tests, meeting end-to-end validation needs.
IDE Support: DevEco Studio integrates testing framework and code test entry points, facilitating execution on real devices/simulators.

Some documentation also mentions HarmonyOS/ArkTS testing capability upgrades in the NEXT version, supporting more modern syntax and parameterization techniques, which can be adopted in your engineering templates as needed (based on official and authoritative sources).

3) Example: UI Scenario Test Framework (extracted from actual project structure)

ArkTS UI Scenario Test Snippet

This test does three things:

If not scanned, try clicking “Start Scan,” otherwise log and skip
Wait for device discovery
Locate device with specified prefix and click connect, assert entry to connected page

This type of UI test case structure aligns with arkXtest’s design philosophy: drive UI operations with APIs, consolidate results uniformly in the testing framework.

4) Make “Test Red → AI Fix → Test Green Again” a Pipeline

Claude Code Loop: When failures occur, paste compilation/runtime logs back into conversation for minimal modification fixes (Claude’s official “environment tuning + context minimization” recommendations are crucial here).
IDE/CI Integration: One-click execution in DevEco Studio locally; CI integration with real devices/simulators for regression (refer to DevEco test entry points and official testing documentation).
Visual Acceptance: Place the manual acceptance step diagrams above in wiki, run Gherkin + UI tests for each version, ensuring “documentation is truth.”

III. Implementation Manual: 7-Step Checklist from 0 to 1

Step 1 | Project Initialization

Create ArkTS project in DevEco Studio; select ArkUI declarative paradigm; confirm target API/device.
Recommend pulling ArkTS style guide and performance practices into repository /guides for both human and AI reference.

Step 2 | One-Page Requirements

Clearly write functionality, value, interfaces, states, exceptions, acceptance scenarios (Given/When/Then).
Place screenshot-style manual acceptance steps in README (the diagram section above).

Step 3 | Claude Code Startup

Use .claude/primer.md and /docs as primary context; limit it from reading irrelevant large files.
Have it generate test stubs & Gherkin first, then supplement business code and ArkUI pages.

Step 4 | ArkTS/ArkUI Coding

Follow naming, componentization, state management constraints; pay attention to performance practices and null/exception handling.

Step 5 | Test Implementation

Use arkXtest / DevEco testing for unit tests + UI tests; use Gherkin as top-level use case description (can call UI test APIs in step definitions).

Step 6 | Iterative Fixes

Feed failure logs to Claude Code for minimal fixes; loop locally/CI until all green.

Step 7 | Knowledge Base Accumulation

Record pitfalls & FAQ in /kb: such as BLE permissions, lifecycle, list performance.
Next time, only need to modify “one-page” requirements and a few step descriptions, Claude Code can reuse context to continue generation.

IV. Results: Quality, Speed, and Understanding – Triple Success

Speed: With the “documentation as code” approach, Claude Code is more stable on HarmonyOS projects, reducing back-and-forth guessing.
Quality: arkXtest + DevEco testing aligns unit tests/UI/performance, automates regression, leaving manual work for exploratory validation only.
Understanding: Standards and performance practices written in documentation, humans and AI follow the same rules, new team members can master ArkTS/ArkUI basics in 1 day.

V. Replicable Template (You Can Copy Directly)

`feature-ble-connect.md` Fragment

Background/Value
Constraints (API/permissions/device prefix)
Acceptance Scenarios (5-7 Given/When/Then items)
Rollout/rollback strategy

Conclusion: Close the Loop Between “Documentation—Testing—Code”

When you write documentation that can directly accept, Claude Code has the possibility to write correct ArkTS on the first try; When you get BDD scenarios running, each version can have one-click regression. This is how we consistently achieve “faster speed + more stable quality” in HarmonyOS projects.

What do you think this approach is still missing? Share your scenarios in the comments.

Use BMAD in Codex like Claude Code: Put a multi‑role AI squad in your repo

Sep 25, 2025

Vibe Sparking

Install Codex and BMAD, map BMAD’s “multi‑role experts” into AGENTS.md, then in the terminal say “*agent analyst”. Codex will run a BMAD‑style agile loop from requirements to delivery.

Introduction

Two pain points in projects: no one writes clear requirements, and even when they do, no one lands them properly.

BMAD turns roles like Business Analysis, Architecture, Product, Development, QA, and Scrum into version‑controlled Markdown agents. Combined with Codex’s AGENTS.md, you work as if an AI squad is embedded in your repo.

This is a practical, copy‑ready path:

Install BMAD
Update AGENTS.md to register BMAD roles
One prompt to bring in the Analyst and start

Why Codex + BMAD?

Codex understands AGENTS.md: it follows your project rules to build, check, and propose changes, in both CLI and IDE.
BMAD provides reusable “Agent as Code”: each role is a .md with tasks, checklists, templates, and workflows.
Together: “project rules + multi‑role collaboration + executable checks.” It feels like a real team that never forgets the process.

Step 1: Install BMAD (3‑minute quick path)

Ensure Node.js v20+ first.

Run in your project root:

# Recommended one‑command install/upgrade
npx bmad-method install

# Or, if you’ve cloned before
git clone https://github.com/bmad-code-org/BMAD-METHOD
cd BMAD-METHOD

git pull
npm run install:bmad

This installs BMAD’s core structure and scripts into your project (including .bmad-core, templates, and helpers), preparing the agents for use.

Tip: If you see path errors, make sure directories include the leading dot (use .bmad-core, not bmad-core). This is a common gotcha.

Step 2: Register BMAD roles in `AGENTS.md`

AGENTS.md is a “README for agents.” It lives at the repo root, as standard Markdown. Use it to document your build/test/style/PR process and any local conventions.

Codex, Cursor, Gemini, and other agents read it; agents will follow rules you define here.

To help Codex quickly locate BMAD roles, add a small “BMAD Agents” section to AGENTS.md and list a clean mapping. Many teams prefer a YAML snippet for clarity and tooling, for example:

# BMAD Agents
agents:
  - id: analyst
    path: .bmad-core/agents/analyst.md
  - id: architect
    path: .bmad-core/agents/architect.md
  - id: bmad-master
    path: .bmad-core/agents/bmad-master.md
  - id: bmad-orchestrator
    path: .bmad-core/agents/bmad-orchestrator.md
  - id: dev
    path: .bmad-core/agents/dev.md
  - id: pm
    path: .bmad-core/agents/pm.md
  - id: po
    path: .bmad-core/agents/po.md
  - id: qa
    path: .bmad-core/agents/qa.md
  - id: sm
    path: .bmad-core/agents/sm.md
  - id: ux-expert
    path: .bmad-core/agents/ux-expert.md

Note: AGENTS.md is Markdown and doesn’t require YAML—tables or lists are fine. The key is to let agents reliably locate those role .md files.

Step 3: Start the BMAD Analyst inside Codex

3.1 Launch Codex

Install the CLI (choose one):

npm i -g @openai/codex
# or
brew install codex

Then run codex in your project root and sign in with your ChatGPT account when prompted.

3.2 “One‑liner” to bring the Analyst online

Once in Codex, say:

*agent analyst

  Hi, I’m Mary — Business Analyst.
  All commands must start with *.

      1. *help — Show available commands
      2. *brainstorm {topic} — Facilitate structured brainstorming
      3. *create-competitor-analysis — Create competitor analysis doc
      4. *create-project-brief — Create project brief
      5. *doc-out — Output current document
      6. *elicit — Run advanced elicitation
      7. *perform-market-research — Create market research doc
      8. *research-prompt {topic} — Generate deep research prompt
      9. *yolo — Toggle skip confirmations
     10. *exit — Exit Business Analyst persona

BMAD’s Web/IDE flows surface *help and *analyst as common entry points. Bringing the same “numbered options + task‑driven” style into Codex gives you a similar experience.

Reminder: BMAD’s Analyst/Architect/PM/Dev roles each define commands/checklists in agents/*.md. Some tasks (e.g., brainstorming) reference files in .bmad-core/tasks/*. If paths are correct, the agent can load them.

A “zero‑to‑one” cheat sheet (use as‑is)

Setup

npx bmad-method install (or npm run install:bmad)
Verify .bmad-core exists and Node v20+ is installed

Configure

Document “how to build/test/code style/PR rules” in AGENTS.md
Add the “BMAD Agents” mapping so role files resolve correctly

Execute

Open codex and send the *agent analyst startup command
Produce docs/brief.md → Architect drafts architecture → Scrum Master shards into stories → Dev implements → QA validates

Make it faster: let Codex handle checks and PRs

Codex naturally runs commands and reviews code in your repo (and can be @‑mentioned in PRs). When paired with AGENTS.md rules for tests/style/build, you get a tight loop of local validation and automated review.

Common pitfalls and fixes

Wrong path: missing the leading dot in .bmad-core causes load failures → standardize on dotted paths.
Scattered rules: put build/test/style/submit conventions in AGENTS.md so agents execute consistently.
Too many roles to remember: use *help in session or have the agent present numbered next steps.

Closing

BMAD turns human roles into versioned code. Codex turns execution into automatable actions. Wire them together and you get an AI team that doesn’t tire, reproduces well, and never forgets the rules.

Which project will you hand to this squad first? Share in the comments.

Quick interaction prompt

Which BMAD role would you customize deeply — Analyst, Architect, or QA?
Share your reason and one team rule that must always be enforced.

Rapidly Develop a HarmonyOS 6 Bluetooth Device Management App with Claude Code: Bluetooth Interaction, ArkTS Compilation Fixes, and TDD/BDD Practices

Sep 22, 2025

Vibe Sparking

Rapidly Develop a HarmonyOS 6 Bluetooth Device Management App with Claude Code: Bluetooth Interaction, ArkTS Compilation Fixes, and TDD/BDD Practices

This article demonstrates how to quickly develop a Bluetooth device management app for Huawei’s HarmonyOS 6 using Claude Code. It covers typical features such as receiving Bluetooth advertisements, connecting to devices, setting the time, synchronizing status, performing infusions, and retrieving logs. The article also focuses on strategies for fixing ArkTS compilation errors and implementing TDD/BDD-oriented testing.

— Suitable for teams aiming to build BLE device applications through a “write, test, iterate quickly” approach.

1. Development Goals and Device Protocol Overview

Target Device: A Bluetooth device.
Typical Commands:
- Read status, synchronize time, perform infusion, read records.

Implementation Files and Data Models:

entry/src/main/ets/utils/BleService.ets: An all-in-one wrapper for scanning and discovery, connection, notifications, and command sending.
entry/src/main/ets/utils/BleCommand.ets: Command construction (including CRC, length, and time/dose encoding).
entry/src/main/ets/utils/BleResponseParser.ets: Response parsing.
entry/src/main/ets/utils/BleAdvertisingParser.ets: Advertising data parsing (local name, UUID, manufacturer data, etc.).

2. How Claude Code Accelerates Native ArkTS Development

Code Navigation and Refactoring:
- Quickly locate BLE-related entry points, cross-references, and dependencies using commands; maintain consistency with batch renaming and interface extraction.
Assisted Fixing of ArkTS Compilation Warnings/Errors:
- Automatically points out rule violations like arkts-no-spread and unknown/any, suggesting replacement code and type completion.
Generating Test Skeletons and Adding Assertions:
- Quickly create and extend unit tests and UI integration tests based on Hypium.

By combining these capabilities, a high-frequency feedback loop of “modify → run tests → analyze logs → fix/refactor” can be established, significantly shortening the cycle from protocol design to an end-to-end working application.

3. Detailed Breakdown of the Bluetooth Interaction Flow

1. Receiving Bluetooth Advertisements (Scanning and Parsing)

Multi-path Scanning (HarmonyOS API v15+):
- Entry Point: entry/src/main/ets/utils/BleService.ets startScan(...)
- Event: BLEDeviceFind is continuously reported, internally using BleAdvertisingParser to parse the local name, service UUID, manufacturer data, etc.
Advertising Parsing: entry/src/main/ets/utils/BleAdvertisingParser.ets
- Covers major AD types like Flags, Complete/Incomplete UUIDs, and Manufacturer Specific Data, making it easy to quickly identify the target device.

Associated Discovery Service: entry/src/main/ets/utils/BleDiscoveryService.ets encapsulates the discovery list, sorting by RSSI, automatic stopping on timeout, and a “trusted device” caching strategy. The UI side can directly subscribe to status/result callbacks.

2. Connecting to a Device and Enabling Notifications

After connecting and discovering services, you must “subscribe, then enable notifications, then read once more” before writing:
- Enable Notifications: entry/src/main/ets/utils/BleService.ets
  - First, subscribe to the callback: gattClient.on('BLECharacteristicChange', ...)
  - Then, enable it: setCharacteristicChangeNotification(..., true)
  - Optionally, perform a readCharacteristicValue once to “warm up” the notification channel (required by some devices).
Notification Callback: entry/src/main/ets/utils/BleService.ets onCharacteristicChanged(...)
- Use lowercase UUID comparison to avoid misses due to case differences.
- Convert characteristic.characteristicValue to an ArrayBuffer before dispatching to a pending callback or a unified protocol parser.

3. Sending and Debugging Commands

Sending a Write: entry/src/main/ets/utils/BleService.ets sendCommand(...)
- ArkTS disables object spreading (no-spread), so characteristicValue must be modified directly before writing.
- Uniformly output hexadecimal strings for easier troubleshooting: BleCommand.toHexString(...)
Command Construction:
- Read Status: entry/src/main/ets/utils/BleCommand.ets
- Synchronize Time: entry/src/main/ets/utils/BleCommand.ets
- Infusion Command: entry/src/main/ets/utils/BleCommand.ets (dose × 1000 converted to an integer, written in little-endian).

4. Synchronizing Time and Reading Status

Synchronize Time: entry/src/main/ets/utils/BleService.ets, writes 0xA7 containing year, month, day, week, hour, minute, and second, then verifies through the notification channel upon completion.
Read Status: entry/src/main/ets/utils/BleService.ets → Wait for notification → Parse: entry/src/main/ets/utils/BleResponseParser.ets
- Parses battery status, voltage/charge, remaining dose, single/daily limits, alarm bits, today’s usage, maximum log entries, etc.

5. Infusion

entry/src/main/ets/utils/BleService.ets calls buildInjectionCommand(dose).
entry/src/main/ets/utils/BleCommand.ets: The dose is encoded as a 4-byte little-endian integer with a precision of 1/1000, accommodating “large/high-precision dose” scenarios.
Recommendations:
- Perform pre-validation against the single/daily limits from the status, and split into packets or send in multiple parts if necessary.
- Pay attention to MTU (typically 20 bytes) limitations and command length design.

6. Retrieving Logs (Record Parsing)

Notification Handling Dispatch: entry/src/main/ets/utils/BleService.ets processReceivedData(...)
- The “ path calls record parsing: entry/src/main/ets/utils/BleResponseParser.ets parseRecord(...)
- Supports two types of structured data: injection records and operation records.
If you need to “fetch historical records by index/type,” you can add a READ_RECORD_WITH_TYPE constructor in BleCommand (a template is commented out in the project), which seamlessly integrates with the parsing logic above.

4. ArkTS Compilation Errors and Key Fixes

Summary Document: docs/ble-arkts-fix-summary.md

Missing Class Properties:
- For example, if connectionPromiseResolvers is not declared, it needs to be added as Map<string, () => void> for external resolution of connection Promises.
arkts-no-spread:
- Object spreading is forbidden when writing characteristic values. Directly modify existing.characteristicValue = ... (see the BleService.ets section).
unknown/any and Loose Literals:
- In notification callbacks, remove temporary Record<string, string>/unknown assertions and use strong typing instead.
Notification Matching and Logging:
- Use lowercase UUID comparison and detailed logging of service/char UUID and hexadecimal payloads for easier on-site debugging.

These fixes, without changing business semantics, make the code satisfy both ArkTS semantics and Lint rules, resulting in a stable and maintainable build.

5. TDD and BDD Testing Practices

1. Unit Testing (TDD)

Device Discovery and Caching:
- entry/src/ohosTest/ets/test/BleDiscoveryService.test.ets
- entry/src/ohosTest/ets/test/DeviceCache.test.ets
Coverage Points:
- Scan status flow, filtering by name, RSSI sorting, automatic stopping.
- Trusted device marking, cache clearing, capacity limits, expiration statistics, etc.
Running Tests:
- hvigor test
- Filter by file: hvigor test --filter BleDiscoveryService

2. Behavior-Driven Development (BDD) and UI Integration

Scenario Use Case: entry/src/ohosTest/ets/test/BleUIIntegration.test.ets
- Start → Begin Scan → Discover Device → Connect → Sync Time/Refresh Status/Send Infusion → Disconnect.
- Utilizes @kit.TestKit’s Driver to find buttons, click, and assert, ensuring an end-to-end path “from UI to protocol.”
Running Tests:
- Full integration test: hvigor test --integration

3. Assertions and Timeout Strategies

Most BLE steps are asynchronous callbacks: set reasonable timeouts for scanning/connecting/writing/notifications (e.g., 5–15s) to avoid false positives.
For critical UI text and buttons, try finding them multiple times to improve stability.
Use hexadecimal logs as an assertion aid (see BleService.ets/BleService.ets).

6. Practical Advice and Common Pitfalls

Notification Order and “Warm-up”:
- The sequence “subscribe → enable notifications → read once” can significantly improve the success rate of the first downstream response for some devices.
MTU and Command Length:
- A typical BLE 4.2 MTU is only 20 bytes. Complex commands need to be split or the negotiation strategy on the device/firmware side needs to be upgraded.
Little-Endian Encoding and CRC:
- The total command length, field encoding, and CRC16 (CCITT/False) calculation must be strictly aligned with the firmware.
Use HiLog Instead of console:
- Use a unified domain/tag and %{public} output (see docs/hilog-migration-summary.md) for easier offline and on-site troubleshooting.
Permissions and Bluetooth Status:
- Unified entry point: entry/src/main/ets/utils/BlePermissionManager.ets ensureBleReady(...). Handle permissions and adapter status all at once before starting a scan.

7. Conclusion and Next Steps

Thanks to Claude Code’s “code navigation + compilation repair + test generation” features, we completed the entire cycle from protocol design to an end-to-end working solution with minimal back-and-forth:

Bluetooth Interaction: The full chain of scanning, connecting, notifications, commands, and record parsing is connected.
ArkTS Fixes: Strictly follows semantics and Lint rules for a stable build.
TDD/BDD: Unit and UI integration tests cover major scenarios, facilitating continuous regression.

Recommended Next Steps:

Add the READ_RECORD_WITH_TYPE command constructor in BleCommand to integrate with the existing parser and complete the “fetch logs by index” feature.
Introduce more granular ViewModel layer state management and data persistence to create a complete “cloud-device-edge” loop with record synchronization.
Refine exception codes and retry strategies to enhance robustness during network disconnection/reconnection.

Claude Code Automates Migration to HarmonyOS BLE v15+ for Multi-Scan and Connection Management

Sep 20, 2025

Vibe Sparking

TL;DR

The HarmonyOS BLE API version used in my previous project (v14 and earlier) had limitations such as single-scan restrictions and incomplete resource management.

Now, using Claude Code to generate and modify code, I was able to understand and automatically migrate to the latest HarmonyOS BLE API v15+, enabling multi-scan and more robust connection management.

Finally, I documented the complete migration process from v14 to v15+, focusing on multi-scan support, advertising data parsing, and connection management optimization.

Background

In the HarmonyOS ecosystem, BLE (Bluetooth Low Energy) is a crucial technology for interconnecting smart devices. As application demands have grown, the limitation of single-scan has become increasingly apparent, especially in scenarios requiring simultaneous scanning for multiple devices or services.

HarmonyOS introduced multi-scan support in API version 15, allowing applications to create multiple independent scanning instances, thereby improving resource management and scanning flexibility.

However, the existing project code was still based on the old API, leading to the following issues:

Single-Scan Limitation: Only one scanning task could be performed at a time, failing to meet the demand for multi-device scanning.
Incomplete Resource Management: Scanner instances were not managed independently, causing state confusion.
Lack of Advertising Data Parsing: Scan results did not parse advertising data, affecting device information retrieval.
Simple Connection Management: The absence of retry and automatic reconnection mechanisms compromised connection stability.

Objective

Based on the latest HarmonyOS BLE API v15+, refactor the existing BLE service code to achieve the following goals:

Multi-Scan Support: Allow multiple scanning tasks to run simultaneously, with each task managed independently.
Independent Resource Management: Each scanner instance is controlled independently to avoid conflicts.
Complete Advertising Data Parsing: Implement parsing of BLE advertising data.
Enhanced Connection Management: Implement connection retry and automatic reconnection mechanisms to improve connection stability.
Modern Asynchronous Handling: Use Promise/async-await to handle asynchronous BLE operations.

Migration Process

1. Read Official Documentation

Before starting the migration, the first step was to download the official documentation to let Claude Code understand the new features and changes in HarmonyOS BLE API v15+.

2. Use Claude Code to Generate Migration Suggestions

I provided the official documentation content to Claude Code and asked it to analyze the problems in the existing code and execute the steps to migrate to the latest API.

> @harmony-os-docs/cn/doc/harmonyos-guides/ble-development-guide.md Recommend using the scanning method supported from API version
  15, which allows applications to initiate and manage multiple scans. Do not use the scanning method supported in API version
  14 and earlier, which only supports single-path scanning.
  ⎿  Read harmony-os-docs/cn/doc/harmonyos-guides/ble-development-guide.md (806 lines)

⏺ I understand. This document highlights important updates for HarmonyOS BLE development:

  Key Points

  API Version Upgrade Recommendation:
  - Recommended: Use the multi-scan method from API version 15+
  - Avoid: The single-scan method from API version 14 and earlier

  Main Differences

  API v15+ (Recommended)

  // Create an independent scanner instance, supporting multi-scan management
  let bleScanner: ble.BleScanner = ble.createBleScanner();

  // Subscribe to scan results
  bleScanner.on('BLEDeviceFind', onReceiveEvent);

  // Start scanning
  bleScanner.startScan([scanFilter], scanOptions);

  // Stop scanning
  bleScanner.stopScan();

  Advantages:
  - ✅ Supports concurrent multi-scanning
  - ✅ Each scanner instance is managed independently
  - ✅ More flexible resource control
  - ✅ Better scan isolation

  API v14 and earlier (Not Recommended)

  // Global singleton scan, only supports single-path
  ble.on('BLEDeviceFind', onReceiveEvent);
  ble.startBLEScan([scanFilter], scanOptions);
  ble.stopBLEScan();

  Limitations:
  - ❌ Only supports single-path scanning
  - ❌ Complex global state management
  - ❌ Cannot manage multiple scanning tasks simultaneously

  Implementation Suggestions

  Based on the example code in the documentation (BleScanManager class), it is recommended that the project adopt the following architecture:

  1. Use BleScanner instance management: Create an independent BleScanner instance for each scanning task
  2. Encapsulate a scan manager: Like the BleScanManager class in the documentation, to uniformly manage the scanning lifecycle
  3. Complete advertising data parsing: Implement full parsing of BLE advertising data
  4. Asynchronous operation handling: Use Promise/async-await to handle asynchronous BLE operations

  This upgrade is particularly important for HarmonyOS projects, as applications may need to scan multiple devices or perform different types of scanning tasks simultaneously.

I will refactor BleService.ets based on the latest specifications of HarmonyOS API v15+ to implement multi-scan management and a more modern BLE operation architecture.

⏺ Code Analysis

  The existing BleService.ets has the following key issues:

  1. Use of deprecated API v14 single-scan: Uses ble.startBLEScan() and ble.on('BLEDeviceFind')
  2. Lack of BLE advertising data parsing: Does not parse advertising data from scan results
  3. Incomplete resource management: Scanner instances are not managed independently
  4. Simple error handling: Lacks fine-grained error recovery mechanisms
...
'''

### 3. Generate Migration Code

Based on the analysis, Claude Code generated new `BleService.ets` code, including support for multi-scanning, advertising data parsing, and enhanced connection management.

```typescript
       481
       482      // Pending response callbacks
       483      private pendingCallbacks: Map<string, (data: ArrayBuffer) => void> = new Map();
       484 +
       485 +    /**
       486 +     * Clean up scanner resources
       487 +     */
       488 +    private cleanupScanner(scanId: string): void {
       489 +      // Clear timer
       490 +      const timer = this.scanTimers.get(scanId);
       491 +      if (timer) {
       492 +        clearTimeout(timer);
       493 +        this.scanTimers.delete(scanId);
       494 +      }
       495 +
       496 +      // Remove from active set
       497 +      this.activeScanners.delete(scanId);
       498 +
       499 +      // Clean up scanner instance
       500 +      this.bleScanners.delete(scanId);
       501 +      this.scanCallbacks.delete(scanId);
       502 +    }
       503 +
       504 +    /**
       505 +     * Set up periodic cleanup of stale discovered devices
       506 +     */
       507 +    private setupDeviceCleanupTimer(): void {
       508 +      setInterval(() => {
       509 +        const now = Date.now();
       510 +        const staleThreshold = 60000; // 60 seconds
       511 +
       512 +        for (const [deviceId, lastSeen] of this.deviceLastSeenTime.entries()) {
       513 +          if (now - lastSeen > staleThreshold) {
       514 +            // Remove stale devices not connected
       515 +            if (!this.connectedDevices.has(deviceId)) {
       516 +              this.discoveredDevices.delete(deviceId);
       517 +              this.deviceLastSeenTime.delete(deviceId);
       518 +              hilog.info(DOMAIN, TAG, `Removed stale device: ${deviceId}`);
       519 +            }
       520 +          }
       521 +        }
       522 +      }, 30000); // Run every 30 seconds
       523 +    }
       524 +
       525 +    /**
       526 +     * Get all discovered devices (including non-connected)
       527 +     */
       528 +    public getDiscoveredDevices(): BleDevice[] {
       529 +      return Array.from(this.discoveredDevices.values());
       530 +    }
       531 +
       532 +    /**
       533 +     * Get active scanner IDs
       534 +     */
       535 +    public getActiveScanners(): string[] {
       536 +      return Array.from(this.activeScanners);
       537 +    }
       538 +
       539 +    /**
       540 +     * Create targeted scan for specific device
       541 +     */
       542 +    public async scanForDevice(
       543 +      deviceId: string,
       544 +      timeout: number = 10000
       545 +    ): Promise<BleDevice | null> {
       546 +      return new Promise((resolve, reject) => {
       547 +        const scanId = `targeted-${deviceId}-${Date.now()}`;
       548 +
       549 +        this.startScan(
       550 +          scanId,
       551 +          (device) => {
       552 +            if (device.id === deviceId) {
       553 +              this.stopScan(scanId);
       554 +              resolve(device);
       555 +            }
       556 +          },
       557 +          { timeout }
       558 +        );
       559 +
       560 +        // Set timeout for not finding device
       561 +        setTimeout(() => {
       562 +          if (this.activeScanners.has(scanId)) {
       563 +            this.stopScan(scanId);
       564 +            resolve(null);
       565 +          }
       566 +        }, timeout);
       567 +      });
       568 +    }
       569    }

4. Code Review and Testing

I conducted a detailed review of the generated code to ensure it met project requirements and performed comprehensive testing on actual devices to verify the stability of the multi-scan and connection management features.

$ hdc file send entry/build/default/outputs/ohosTest/entry-ohosTest-signed.hap "data/local/tmp/6a550b34422f402d80438c69110c772e"
$ hdc shell bm install -p data/local/tmp/6a550b34422f402d80438c69110c772e
$ hdc shell rm -rf data/local/tmp/6a550b34422f402d80438c69110c772e
Running tests.

$ hdc shell aa test -b com.vibersparking.ble_test -m entry_test -s unittest OpenHarmonyTestRunner -s class BleServiceTest -s timeout 15000

Started running tests.

Test finished.

5. Summary Documentation

Finally, I had Claude Code generate a complete summary document, recording the entire process of migrating from HarmonyOS BLE API v14 to v15+, including multi-scan support, advertising data parsing, and enhanced connection management features.

Core Changes

1. API Version Comparison

Feature	API v14 and earlier	API v15+
Scanning Method	Single-scan (global)	Multi-scan (instantiated)
Scanner Management	`ble.startBLEScan()`	`ble.createBleScanner()`
Scan Event	`ble.on('BLEDeviceFind')`	`bleScanner.on('BLEDeviceFind')`
Stop Scanning	`ble.stopBLEScan()`	`bleScanner.stopScan()`
Resource Management	Global state	Independent instance management

2. Key Advantages

Concurrent Multi-Scanning: Supports running multiple scanning tasks simultaneously
Independent Resource Management: Each scanner is controlled independently, avoiding conflicts
Better Error Isolation: Failure of a single scan does not affect other scans
Flexible Filter Configuration: Each scan can have its own independent filter conditions

Implementation Architecture

Core Service Structure

export class BleService {
  // API v15+ scanner management
  private bleScanners: Map<string, ble.BleScanner> = new Map();
  private activeScanners: Set<string> = new Set();
  private scanCallbacks: Map<string, (device: BleDevice) => void> = new Map();
  private scanTimers: Map<string, number> = new Map();

  // Device cache management
  private discoveredDevices: Map<string, BleDevice> = new Map();
  private deviceLastSeenTime: Map<string, number> = new Map();

  // Connection management
  private autoReconnectDevices: Set<string> = new Set();
  private connectionRetryCount: Map<string, number> = new Map();
}

Multi-Scan Implementation

public startScan(
  scanId: string,
  callback: (device: BleDevice) => void,
  options?: BleStartScanOptions
): void {
  // Check for scan ID uniqueness
  if (this.activeScanners.has(scanId)) {
    hilog.warn(DOMAIN, TAG, `Scanner ${scanId} already active`);
    return;
  }

  try {
    // Create an independent scanner instance (API v15+)
    const bleScanner = ble.createBleScanner();
    this.bleScanners.set(scanId, bleScanner);
    this.scanCallbacks.set(scanId, callback);

    // Configure scan filters
    const scanFilters: ble.ScanFilter[] = [];
    if (options?.filterServiceUuid) {
      scanFilters.push({
        serviceUuid: SERVICE_UUID
      });
    }

    // Subscribe to scan results
    bleScanner.on('BLEDeviceFind', (scanReport: ble.ScanReport) => {
      this.onDeviceFoundV15(scanId, scanReport);
    });

    // Start scanning
    bleScanner.startScan(scanFilters, scanOptions);
    this.activeScanners.add(scanId);

    // Set auto-stop timer
    const timeout = options?.timeout || SCAN_TIMEOUT_MS;
    const timer = setTimeout(() => {
      if (this.activeScanners.has(scanId)) {
        this.stopScan(scanId);
      }
    }, timeout);
    this.scanTimers.set(scanId, timer);

  } catch (error) {
    this.cleanupScanner(scanId);
    throw error;
  }
}

BLE Advertising Data Parser

export class BleAdvertisingParser {
  public parse(data: ArrayBuffer): ParsedAdvertisingData {
    const result: ParsedAdvertisingData = {
      serviceUuids: [],
      serviceSolicitationUuids: [],
      serviceData: new Map(),
      manufactureSpecificData: new Map(),
      rawData: data
    };

    const advData = new Uint8Array(data);
    let position = 0;

    while (position < advData.byteLength) {
      const length = advData[position++];
      if (length === 0) break;

      const type = advData[position++];
      const dataLength = length - 1;
      const dataStart = position;

      switch (type) {
        case AdvertisingDataType.FLAGS:
          result.flags = advData[dataStart];
          break;
        case AdvertisingDataType.LOCAL_NAME_COMPLETE:
          result.localName = this.parseString(advData, dataStart, dataLength);
          break;
        case AdvertisingDataType.SERVICE_UUID_16_COMPLETE:
          this.parseServiceUuids(advData, dataStart, dataLength, 2, result.serviceUuids!);
          break;
        case AdvertisingDataType.MANUFACTURER_SPECIFIC_DATA:
          this.parseManufacturerData(advData, dataStart, dataLength, result.manufactureSpecificData!);
          break;
      }
      position += dataLength;
    }

    return result;
  }
}

Enhanced Connection Management

public async connectDevice(
  deviceId: string,
  options?: BleConnectOptions
): Promise<void> {
  const timeout = options?.timeout || CONNECTION_TIMEOUT_MS;
  const retryCount = options?.retryCount || 3;
  const autoReconnect = options?.autoReconnect !== false;

  // Implement retry logic
  let lastError: Error | null = null;

  for (let attempt = 1; attempt <= retryCount; attempt++) {
    try {
      await this.connectWithTimeout(deviceId, timeout);

      if (autoReconnect) {
        this.autoReconnectDevices.add(deviceId);
      }

      return; // Success
    } catch (error) {
      lastError = error as Error;

      if (attempt < retryCount) {
        // Exponential backoff retry
        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
        await this.delay(delay);
      }
    }
  }

  throw new Error(`Failed to connect after ${retryCount} attempts: ${lastError?.message}`);
}

Migration Steps

1. Update Imports and Type Definitions

// Add new interface definitions
interface BleStartScanOptions {
  timeout?: number;
  filterServiceUuid?: boolean;
  filterManufacturerId?: boolean;
}

interface BleConnectOptions {
  timeout?: number;
  retryCount?: number;
  autoReconnect?: boolean;
}

2. Replace Scanning Implementation

Old Code (v14):

ble.startBLEScan([scanFilter], scanOptions);
ble.on('BLEDeviceFind', (devices: Array<ble.ScanResult>) => {
  this.onDeviceFound(devices);
});

New Code (v15+):

const bleScanner = ble.createBleScanner();
bleScanner.on('BLEDeviceFind', (scanReport: ble.ScanReport) => {
  this.onDeviceFoundV15(scanId, scanReport);
});
bleScanner.startScan([scanFilter], scanOptions);

3. Implement Resource Cleanup

private cleanupScanner(scanId: string): void {
  // Clear timer
  const timer = this.scanTimers.get(scanId);
  if (timer) {
    clearTimeout(timer);
    this.scanTimers.delete(scanId);
  }

  // Remove active scanner
  this.activeScanners.delete(scanId);

  // Clean up scanner instance
  this.bleScanners.delete(scanId);
  this.scanCallbacks.delete(scanId);
}

4. Add Device Cache Management

private setupDeviceCleanupTimer(): void {
  setInterval(() => {
    const now = Date.now();
    const staleThreshold = 60000; // 60 seconds

    this.deviceLastSeenTime.forEach((lastSeen, deviceId) => {
      if (now - lastSeen > staleThreshold) {
        if (!this.connectedDevices.has(deviceId)) {
          this.discoveredDevices.delete(deviceId);
          this.deviceLastSeenTime.delete(deviceId);
        }
      }
    });
  }, 30000);
}

Usage Examples

Basic Scanning

const bleService = BleService.getInstance();

// Start scanning
bleService.startScan(
  'scan-1',
  (device) => {
    console.log(`Found device: ${device.name}`);
  },
  {
    timeout: 30000,
    filterServiceUuid: true
  }
);

Concurrent Multi-Scanning

// Scan for a specific service
bleService.startScan('service-scan', callback1, {
  filterServiceUuid: true
});

// Scan for a specific manufacturer
bleService.startScan('manufacturer-scan', callback2, {
  filterManufacturerId: true
});

// General scan
bleService.startScan('general-scan', callback3, {
  timeout: 60000
});

Connection Management

// Connect with retry and auto-reconnect
await bleService.connectDevice(deviceId, {
  timeout: 10000,
  retryCount: 3,
  autoReconnect: true
});

// Listen for connection state changes
bleService.addConnectionStateListener(deviceId, (state, prevState) => {
  console.log(`Connection state changed: ${prevState} -> ${state}`);
});

Best Practices

Scan Management
- Assign a unique ID to each scanning task
- Set a reasonable timeout
- Clean up unnecessary scanners promptly
Device Cache
- Implement an expiration mechanism to avoid memory leaks
- Retain information about recently discovered devices
- Support quick reconnection
Error Handling
- Implement a retry mechanism
- Use an exponential backoff strategy
- Provide detailed error logs
Resource Optimization
- Avoid duplicate scanning
- Set scanning parameters reasonably
- Release GATT clients promptly

Performance Optimization Suggestions

Scanning Optimization

const scanOptions: ble.ScanOptions = {
  interval: 0, // No delay reporting
  dutyMode: ble.ScanDuty.SCAN_MODE_LOW_LATENCY, // Low latency mode
  matchMode: ble.MatchMode.MATCH_MODE_AGGRESSIVE // Aggressive matching
};

Connection Optimization
- Implement a connection pool
- Cache discovered services in advance
- Batch process notification data
Memory Management
- Periodically clean up expired devices
- Limit cache size
- Avoid memory leaks

Troubleshooting

Common Issues

No Scan Results
- Check Bluetooth permissions
- Verify that Bluetooth is enabled
- Confirm that filter conditions are correct
Connection Failed
- Increase the number of retries
- Extend the timeout period
- Check if the device is in range
Resource Leaks
- Ensure all scanners are cleaned up
- Close GATT clients correctly
- Clean up event listeners

Conclusion

The API v15+ upgrade brings significant improvements:

✅ Supports concurrent multi-scanning
✅ Independent resource management
✅ Better error isolation
✅ Flexible configuration options
✅ Enhanced stability

By following this guide, you can smoothly migrate from v14 to v15+, taking full advantage of the new API to provide a more stable and efficient BLE connection experience.

Build a WeChat Chat Daily Report with Claude Code: chatlog + MCP in 3 Steps

Sep 18, 2025

Vibe Sparking

Turn yesterday’s group and private chats into a one‑click daily report: top keywords, key people, to‑dos, and risk alerts — fully automated.
This guide walks you through using Claude Code + chatlog to squeeze insights from chat data, with copy‑paste‑ready prompts.

What You’ll Get

End‑to‑end flow: export/decrypt → start HTTP → connect to Claude Code (MCP) → one‑click daily report
Prompt templates: ready to copy for data fetch, analysis/aggregation, and report generation (Markdown/HTML/images)
Best practices: keyword radar, sensitive‑term alerts, to‑do extraction, sentiment curve
Pitfall checklist: keys, SIP, remote/local connectors, CSV/audio

chatlog is an open‑source tool that supports local WeChat database access, automatic decryption, HTTP API, Webhook, and MCP Streamable HTTP, so Claude Code can use it directly as a “data tool”.

1. Setup (10 minutes)

1) Install and start chatlog (local)

# Install (choose one)
go install github.com/sjzar/chatlog@latest
# Or download a prebuilt binary from Releases

In the TUI, select Decrypt Data → Start HTTP Service (default http://127.0.0.1:5030).
API examples:

GET /api/v1/chatlog?time=2025-09-17&talker=wxid_xxx&format=json
GET /api/v1/contact
GET /api/v1/session

Supports YYYY-MM-DD or YYYY-MM-DD~YYYY-MM-DD windows; format supports json/csv/text.

Tip: First obtain the data key/image key. On macOS, you may need to temporarily disable SIP to extract keys (re‑enable afterwards).

2) Expose chatlog to Claude Code as an MCP server

chatlog natively supports MCP Streamable HTTP. Once HTTP is running, the endpoint is:

GET http://127.0.0.1:5030/mcp

Add a remote MCP in Claude Code:

# Syntax from the official example: claude mcp add --transport http <name> <url>
claude mcp add --transport http chatlog http://127.0.0.1:5030/mcp

Then in Claude Code, use /mcp to manage and use tools.

MCP is an open standard by Anthropic with Streamable HTTP transport and OAuth/Token auth, making it easy to plug external data into AI assistants.

Note: Remote MCP support is being rolled out. You can also use local STDIO. Capabilities depend on your account and version.

2. A low‑friction daily report structure (Claude can generate it directly)

Today’s overview: total messages, active sessions, top groups/DMs, peak hours
Keyword radar: TF‑IDF/key phrases/topic clustering (merge synonyms)
Task extraction: a to‑do list triggered by phrases like “tomorrow/tonight/please/help me/to‑do/schedule”
Risk alerts: custom sensitive/compliance term hits with counts and context
Sentiment curve: hourly distribution (positive/neutral/negative) with anomalous peaks highlighted
High‑value snippets: top 5 highest information‑density excerpts (with session name/timestamp/message ID)
Appendix: raw data links (APIs can deep‑link to decrypted images/files/audio streams)

3. Claude Code prompts (copy‑paste ready)

Usage: replace variables in {}; paste directly into Claude Code.
Below includes the recommended MCP approach and an HTTP‑only fallback (curl/script).

A. Connection check & list tools

You are now connected to an MCP server: name=chatlog, endpoint=http://127.0.0.1:5030/mcp.
1) List all tools/resources provided by chatlog and briefly describe their purpose.
2) Check whether it can query chat logs, contacts, session lists, and media access.
3) If there are pagination/limit parameters, tell me the defaults and maximums.

B. Fetch all messages from yesterday (grouped by session)

Goal: Generate the “WeChat Chat Daily Report ({date})”.

Data fetch requirements:
- Date range: {date} 00:00:00 ~ {date} 23:59:59 (local timezone)
- Fetch up to {per_chat_limit} per session, up to {global_limit} overall
- Fields: time, talker, isChatRoom, sender, content, type, subType
- If a message has media (image/file/audio), record an accessible URL

Actions:
- Call chatlog’s tool/HTTP API: /api/v1/chatlog?time={date}~{date}&format=json&limit={global_limit}
- On failure, retry 2 times and record failed sessions
- Aggregate results by session ID; summarize per‑session message counts and an activity histogram

Output: generate data.json (containing raw and aggregated data)

(API shape per README; chatlog dynamically decrypts/serves media as accessible paths.)

C. Keyword radar & to‑do extraction

For data.json:
1) Perform Chinese tokenization + stopword removal + synonym merging (e.g., “OK/好的/行/可以” consolidated).
2) Output the top 20 keywords (weights, example sentences, and the sessions where they frequently appear).
3) Using rules + LLM, extract to‑dos (owner, action verb, due time, context link).
4) Maintain a sensitive term list (I’ll supply) and produce hit counts with a ±3‑sentence context window.

Outputs: keywords.json, todos.json, alerts.json

D. Sentiment and peak hours

Assign a coarse sentiment label (positive/neutral/negative) to each message and aggregate by hour into a curve.
Detect anomalous peaks (e.g., >3σ) and list the sessions and key snippets responsible.
Outputs: sentiment_by_hour.csv, peaks.md (with explanations)

E. Generate the report (Markdown + HTML + images)

Assemble {keywords.json, todos.json, alerts.json, sentiment_by_hour.csv} into the “Chat Daily Report ({date})”.

Layout:
- Today’s overview (include a data table)
- Keyword radar (word cloud + one‑line summary per term)
- To‑do list (owner/due/link)
- Risk alerts (term/count/context jump)
- Sentiment curve (line chart)
- Top 5 high‑value snippets (with session name/timestamp)

Requirements:
- First output Markdown (report.md), then render a minimalist HTML (report.html with inline styles)
- Images: generate two figures (word cloud, sentiment curve) in ./assets and reference in HTML
- Provide a final “one‑click copy” Markdown block

F. Quick HTTP‑only fallback (no MCP required)

# Fetch yesterday’s data (JSON)
curl -G "http://127.0.0.1:5030/api/v1/chatlog" \
  --data-urlencode "time=2025-09-17~2025-09-17" \
  --data-urlencode "limit=5000" \
  --data-urlencode "format=json" > data.json

API params and media decryption/serving are provided by chatlog.

4. Best practices: make the report smarter

Synonym map: normalize common colloquialisms to reduce word‑cloud noise.
To‑do extraction rules: regex + few‑shot tuned to phrases like “help me”, “remember to”, “by tonight”.
Role profiling: score members by talk density/influence to spot “information sources”.
Webhook increments: pair chatlog’s Webhook with your middleware to push deltas as new messages arrive.
CSV/audio: recent versions improved CSV and audio pipelines — check the Releases Changelog.

5. Pitfall checklist

Only process data you legally own. Respect privacy and platform terms; the project emphasizes this as well.
On macOS, obtaining keys may require temporarily disabling SIP; re‑enable afterwards.
Remote MCP support is rolling out; local STDIO is more stable. Check your account/version.
MCP connection syntax follows the official docs: claude mcp add --transport http <name> <url>.
MCP concepts/auth: use Streamable HTTP with standard auth for safer team deployments.

Deploy chatlog with Docker on a NAS and pre‑set CHATLOG_WEBHOOK_* env vars to integrate your toolchain.
Use Claude Connectors/MCP catalogs to manage multiple sources so non‑technical teammates can connect with a click.

Conclusion

Treat chats as data and use Claude Code to refine them into an actionable team daily.
Spend 3 minutes skimming each day and get time back for what actually matters.

Resolve Git Merge Conflicts with Claude Code

Sep 17, 2025

Vibe Sparking

Using Claude Code to handle Git branch merges and resolve conflicts

In modern software development, Git merges and conflict resolution are everyday tasks. Claude Code, as an intelligent development assistant, can significantly speed up and harden these workflows. This post walks through practical scenarios showing how to use Claude Code to handle a variety of merge cases.

Core Capabilities at a Glance

Claude Code’s strengths for Git operations:

Intelligent conflict analysis: identifies root causes and proposes optimal solutions
Batch operations: resolve conflicts across many files at once
Code‑semantic understanding: resolves based on logic, not just textual diffs
Automated verification: runs tests after merges to ensure correctness

Example 1: Feature Branch Merge with a Simple Conflict

Scenario

You’re building a React app. The feature/user-auth branch implements user authentication and needs to be merged into main. Both branches modified App.tsx.

Claude Code Workflow

User: Please merge feature/user-auth into main and resolve any conflicts.

Claude Code:

Let me help you complete the merge. First, I’ll check the current state:

[run git status and git branch -a]
[run git checkout main]
[run git pull origin main]
[run git merge feature/user-auth]

Found a conflict in src/App.tsx. Analyzing the conflict:

Conflict region:
- main branch: added a new navigation component
- feature/user-auth: added an authentication wrapper

These changes are complementary. I’ll keep both:

[auto-edit App.tsx, semantically integrating both changes]
[run git add src/App.tsx]
[run npm test to verify]
[run git commit]

Merge complete! All tests passed. The new App.tsx includes both navigation and authentication.

Key Points

Detects complementary vs. mutually exclusive changes
Semantically integrates code instead of naïve text splicing
Automatically runs tests to validate the merge

Example 2: Multi‑File Conflicts with Cross‑Dependency Changes

Scenario

In a Node.js microservice, feature/database-migration updates the DB schema while main adds new API endpoints. Conflicts span multiple files and dependencies.

Claude Code Workflow

User: Merge feature/database-migration into main. This branch changes DB models.

Claude Code:

I’ll handle this systematically. First, scope the impact:

[run git diff main...feature/database-migration --name-only]

Potential conflicts detected:
- package.json (dependency version conflicts)
- src/models/User.js (model structure changes)
- src/controllers/UserController.js (API logic conflict)
- migrations/20240315_user_table.sql (migration script)

Proceeding with merge resolution:

1) package.json dependencies:
   - Keep newer mongoose: ^7.0.3
   - Merge in the migration tool dependency
   [auto-edit package.json]

2) User model conflict:
   - Integrate new fields
   - Update validation rules
   - Maintain backward compatibility
   [semantic refactor of User.js]

3) Update UserController to fit the new model:
   - Adjust query logic
   - Update response shapes
   [auto-edit controller code]

4) Validate migration scripts:
   - Ensure correct ordering
   - Add rollback script
   [create supplemental migration file]

[run npm install]
[run npm run migrate]
[run npm test]

All conflicts resolved and tests passed. Recommend integration testing before deployment.

Key Points

Handles cross‑file dependencies and ripple effects
Identifies related files that must change together
Generates necessary migration and rollback scripts

Example 3: Emergency Hotfix Merge and Bug Repair

Scenario

There’s a production critical bug. hotfix/payment-calculation contains a fix, but conflicts with develop. It needs to be merged into both main and develop.

Claude Code Workflow

User: Urgent! Merge hotfix/payment-calculation into main and develop. It fixes a severe payment calc bug.

Claude Code:

Understood — correctness first.

Phase 1: Merge into main (production)

[run git checkout main]
[run git merge --no-ff hotfix/payment-calculation]

Conflict in src/services/PaymentService.js:
- hotfix fixes a formula error
- main has code formatting changes

Keep the fix and apply formatting:
[semantic merge; retain fix, apply formatting]

Validate the fix:
[add targeted tests for the bug]
[run npm run test:payment]

Phase 2: Merge into develop (avoid regressions)

[run git checkout develop]
[run git merge hotfix/payment-calculation]

More complex conflict:
- develop is refactoring the payment module
- fix must be adapted to the new architecture

Adapt the fix to the new structure:
[analyze new module; transplant fix]
[update affected unit tests]
[add regression tests]

Phase 3: Verification and docs

[run full test suite]
[generate a fix report]

Fix successfully applied to both branches!

Summary of changes:
- Fixed floating‑point precision issue
- Introduced BigDecimal for monetary math
- Added boundary‑condition test coverage

Recommend immediate production deployment.

Key Points

Prioritization and risk management for hotfixes
Porting fixes across different architectures
Autogenerated regression tests to prevent recurrence

Advanced Tips and Best Practices

1) Pre‑merge Conflict Preview

User: Preview potential conflicts before merging.

Claude Code:
[run git merge --no-commit --no-ff feature/branch]
[analyze conflicts and propose resolutions]
[run git merge --abort to roll back preview]

2) Smart Conflict Strategy Selection

User: For this file, which side should we keep?

Claude Code:
Based on code semantics and test coverage, I suggest:
- API route files: keep both (additive features)
- Config files: prefer the feature branch (new options)
- Stylesheets: manual review recommended (visual impact)

3) Automated Post‑merge Verification

Claude Code automatically runs:
- static analysis
- unit tests
- integration tests
- coverage checks
- performance benchmarks

Frequently Asked Questions

Q1: How to handle binary file conflicts?

Claude Code will detect binary files and offer:

keep a specific version
regenerate the file
manually choose the version

Q2: How to roll back a bad merge?

Supported options:
- git reset --hard HEAD~1 (if not pushed)
- git revert -m 1 <merge-commit> (if already pushed)
- automatically create a repair branch

Q3: How to deal with submodule conflicts?

Claude Code can:

detect version conflicts
suggest appropriate commit revisions
update .gitmodules

Performance Tips

Batch conflict resolution: resolve multiple files in parallel
Smart merge strategies: choose by file type
Leverage caching: use Git rerere to remember resolutions

Conclusion

Claude Code turns Git merging from a tedious manual process into a smarter, automated workflow. With semantic understanding, automated testing, and intelligent conflict resolution, it improves both developer efficiency and code quality.

Key advantages:

Up to 80% less time spent on conflicts
Automated tests guard merge quality
Smart suggestions avoid common mistakes
Complete, reviewable operation history

In production projects, integrate Claude Code into CI/CD for even more automation. While Claude Code is powerful, architectural decisions should still be reviewed by humans.

Smart APK Naming for Flutter Android Builds with Claude Code

Sep 17, 2025

Vibe Sparking

Make APKs readable at a glance: channel, environment, version, branch, timestamp — no manual renaming.

Let Claude Code inject the naming rule into android/app/build.gradle. Every build outputs a descriptive filename.

Example output: TestAApp-release-v1.0+1-main-20250918-102530.apk Includes: app name + build type + version name/code + git branch + timestamp.

— Official Flutter build paths and Gradle references are listed at the end.

Use Claude Code: one prompt to patch `build.gradle`

Copy one of the prompts below into Claude Code.

Prompt: Quick Rename

You are an Android/Flutter build engineer. In my Flutter project’s
android/app/build.gradle (Groovy), please add:
1) getGitBranchName(): prefer `git rev-parse`, fallback to env GIT_BRANCH;
2) Parse -Pdart-defines (Base64 list from Flutter --dart-define) and decode to a Map;
3) Generate APK name: {AppName}-{buildType}-v{versionName}+{versionCode}-{gitBranch}-{yyyyMMdd-HHmmss}.apk;
4) In the corresponding variant’s assemble task doLast, copy and rename the output;
5) Print a log: “Renamed APK generated: path/filename”.
Do not replace existing config; only append what’s required. Keep valid Groovy syntax.

Prompt: With Validation

Inspect my current android/app/build.gradle and AGP version:
- If setting outputFileName directly may not work, use the “copy-after-assemble” approach;
- Support multiple flavors/build types;
- Provide a minimal invasive patch and explain each added line.

Prompt: CI-Friendly

Enhance for GitHub Actions:
- If `git rev-parse` is unavailable, read `$GITHUB_REF_NAME` as the branch name;
- Place the new APK in {project}/android/app/build/outputs/apk/{buildType}/;
- Print the full path to stdout for later artifact upload steps.
Output only a final, runnable Groovy code block.

Why rename the APK file?

By default it’s app-release.apk. When sending to QA or uploading to CI artifacts, everything has the same name. It’s guesswork to identify versions — frustrating and error-prone.

With a descriptive name you immediately know:

Which branch produced it
Which version it is
When it was built

Productivity goes up immediately.

What you need

A standard Flutter/Android project.
Any Android Gradle Plugin (AGP) version works, but naming approaches differ. The robust approach is to copy/rename after assemble. That’s the path used below and is widely adopted under newer AGP APIs.
Flutter’s --dart-define values are passed via Gradle -Pdart-defines as Base64. We can decode and read them in build.gradle.

Copy and use: add this to `android/app/build.gradle`

Place under the android { ... } section with applicationVariants (Groovy syntax). Idea: get branch name + decode --dart-define + build the new file name + copy/rename after assemble. This “copy and rename” technique is more reliable across AGP versions.

// Read git branch (fallbacks for CI)
def getGitBranchName() {
    try {
        def branch = "git rev-parse --abbrev-ref HEAD".execute().text.trim()
        return (branch ?: System.getenv("GIT_BRANCH") ?: "unknown").replace('/', '-')
    } catch (Exception e) {
        return System.getenv("GIT_BRANCH") ?: "unknown"
    }
}

android {
    // ... your existing config ...
    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            // 1) Parse Flutter --dart-define (in Gradle as -Pdart-defines, Base64)
            def dartDefinesMap = [:]
            if (project.hasProperty('dart-defines')) {
                def raw = project.property('dart-defines')
                def entries = []
                if (raw instanceof List) entries.addAll(raw)
                else if (raw instanceof String) entries.addAll(raw.split(','))
                entries.each { item ->
                    try {
                        def decoded = new String(item.decodeBase64())
                        def kv = decoded.split('=', 2)
                        if (kv.length == 2) dartDefinesMap[kv[0]] = kv[1]
                    } catch (Exception ignored) { }
                }
            }

            // 2) Optional environment keys from dart-define
            def appName = "TestAApp"
            def buildType = variant.buildType.name
            def versionName = variant.versionName
            def versionCode = variant.versionCode
            def gitBranch = getGitBranchName()
            def timestamp = new Date().format("yyyyMMdd-HHmmss")

            def newApkName = "${appName}-${buildType}-v${versionName}+${versionCode}-${gitBranch}-${timestamp}.apk"

            // 3) After assemble for this variant, copy and rename the artifact
            variant.assembleProvider.get().doLast {
                def outDir = output.outputFile.parent
                copy {
                    from(output.outputFile)
                    into(outDir)
                    rename { newApkName }
                }
                println "✅ Renamed APK generated: $outDir/$newApkName"
            }
        }
    }
}

Notes:

Local uses git rev-parse; CI can fallback to the GIT_BRANCH environment variable.
Newer AGP often breaks “rename in place”; copy+rename is the portable approach.
See Flutter docs for build configuration locations and packaging steps.

How to pass `--dart-define`

Command example:

# Release build (example env flags)
flutter build apk --release \
  --dart-define=LOG_SHOW_PREFIX=false \
  --dart-define=CHANNEL=official

Flutter encodes these --dart-define entries in Base64 and injects them as -Pdart-defines. The Gradle snippet above decodes them into a Map.

Common pitfalls (pre‑solved here)

In‑place rename sometimes fails New AGP Variant APIs changed. Community practice favors “copy + rename after assemble”.
Flutter output directory quirks Some builds land under flutter-apk/ or ignore outputFileName. Use the copy+rename fallback.
CI with detached HEAD git rev-parse can’t read the branch. Use env fallback (GIT_BRANCH or CI‑specific vars).

One command to get the artifact

flutter build apk --release \
  --dart-define=LOG_SHOW_PREFIX=false \
  --dart-define=CHANNEL=official
# Output like:
# android/app/build/outputs/apk/release/TestAApp-release-v1.0+1-main-20250918-102530.apk

Compare with the official documentation for build entry points and directory structure.

Wrap‑up

Bake the naming rule into the build step so every artifact is self‑describing. QA hand‑off, tracebacks, and bug hunts all get easier. Claude Code turns these “small but annoying” chores into a one‑time setup you can reuse.

Anything else you want included in the name? For example, short git hash, channel, target ABI?

3 alternative titles and slugs

Rename APKs the Smart Way: Claude Code Automates Flutter Android File Names slug: smart-apk-naming-with-claude-code
One‑Click APK Renaming with Version, Branch and Timestamp slug: one-click-flutter-apk-rename
Stop Shipping app-release.apk: Make Releases Self‑Describing slug: stop-shipping-app-release-apk

Cover and illustration prompts (2:1, no text)

Cover prompt: “Flat illustration, dev workspace at night, laptop building Android app, APK file icon morphs into a labeled package showing version, branch, timestamp, gentle neon lights, clean vector shapes, 2:1.”

Illustration #1 (where the code goes): “Diagram‑style illustration, build.gradle file with highlighted code blocks, arrows from git branch and dart‑define to ‘new APK name’, minimalistic, vector, 2:1.”

Illustration #2 (pipeline scene): “CI/CD conveyor belt turning generic app-release.apk into descriptive files with tags (release, v1.0+1, main, 20250918), playful but professional, vector, 2:1.”

“Everything used to be app-release.apk — I’d install the wrong build all the time. Now the file name carries version/branch and I never guess. 😎”
“No time to read? Paste the prompts into Claude Code. In 5 minutes your Gradle is set up and you save half a day of back‑and‑forth.”
“QA no longer asks ‘who built this and where did it come from?’. The name tells the story. Communication cost = 0.”

References:

Claude Code + ArkTS for HarmonyOS: Build a BLE Manager in Minutes

Sep 16, 2025

Vibe Sparking

Use Claude Code as your “pair programmer who knows HarmonyOS ArkTS” to build a BLE manager that can scan / connect / read-write / subscribe — runnable on a real device with logs for debugging.

Intro | Why Claude Code + ArkTS?

Anyone who has built a BLE manager knows: the protocol is fragmented, device vendors differ wildly, and versions change fast. HarmonyOS/ArkTS docs are large and spread out — newcomers get lost easily. My practical approach: feed the official documentation into Claude Code and let it be a “code-with-the-manual-open” partner in the editor; we stay focused on business logic and debugging flow.

ArkTS is the preferred native language for HarmonyOS, enhancing TypeScript with stronger static checks and performance (see official docs: https://developer.huawei.com/consumer/cn/arkts/).
BLE on HarmonyOS uses @ohos.bluetooth.ble, with core capabilities for scanning, advertising, and GATT client/server.
Real data interaction goes via GATT: reading/writing characteristics and subscribing to notifications.

The benefit of this combo: fewer guesses and directly coding to the docs. Claude Code searches, cross-checks, and completes; you control architecture, state machine, and logging.

Preparation | Put the docs into Claude’s “stomach”

Goal context
We’ll build an ArkTS app that connects to BLE devices.
Download official docs and add a local folder
Grab the ArkTS & BLE docs (guides + API references) from Huawei Developers, and store them offline in your project under /harmony-os-docs/.

Write a CLAUDE.md (sample)
Treat Claude Code as a teammate and require it to strictly consult these docs before generating ArkTS code and explanations:

# CLAUDE.md (excerpt)

You are my ArkTS + BLE copilot. Always quote and align with these docs:

### ArkTS
- @harmony-os-docs/cn/doc/harmonyos-guides/typescript-to-arkts-migration-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-coding-style-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-high-performance-programming.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-migration-background.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-more-cases.md
- @harmony-os-docs/cn/doc/harmonyos-guides/introduction-to-arkts.md

### BLE (HarmonyOS)
- @harmony-os-docs/cn/doc/best-practices/bpta-bluetooth-low-energy.md
- @harmony-os-docs/cn/doc/best-practices/bpta-reasonable-bluetooth-use.md
- @harmony-os-docs/cn/doc/harmonyos-guides/ble-development-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/br-development-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/gatt-development-guide.md

Rules:
- Prefer ArkTS idioms and coding style.
- Cite doc path + section when uncertain.
- If API differs by version, note the min API level & capability.

The key here is to constrain Claude: if it’s unsure, check; if it’s uncertain, annotate. ArkTS style guidance and performance tips can be referenced directly in code review.

Quick Prototype | ArkTS + BLE basic moves

Permissions & abilities
Declare required permissions in entry/src/main/module.json5 (adjust per your API level/version):

ohos.permission.USE_BLUETOOTH (enable Bluetooth)
ohos.permission.DISCOVER_BLUETOOTH (scan/configure)
ohos.permission.LOCATION (location permission often required for scanning; follow UX requirements for foreground disclosure)

Module entry
ArkTS BLE uses @ohos.bluetooth.ble. Scan results come from ble.on('BLEDeviceFind', cb). After discovering a device, create GattClientDevice to connect and perform GATT read/write/subscribe.

The official “BLE best practices for scanning/connection state management” also provides suggestions for a business-layer state machine; consider persisting those.

Code | A practical ArkTS BLE Manager

Open Claude Code and ask it to implement:

> Write a `BleManager` class that can enable/scan/connect/read/write/subscribe/disconnect and exposes state + error callbacks.
Location: `entry/src/main/ets/utils/BleManager.ets`
Capabilities: enable/scan/connect/read/write/subscribe/disconnect/state management/key logs

Generated code

// entry/src/main/ets/utils/BleManager.ets
import ble from '@ohos.bluetooth.ble';
import { BusinessError } from '@ohos.base';

type Device = {
  deviceId: string;           // e.g., "XX:XX:XX:XX:XX:XX"
  name?: string;
  rssi?: number;
  advData?: Uint8Array;
};

type ConnectionState = 'idle' | 'scanning' | 'connecting' | 'connected';

export class BleManager {
  private static _i: BleManager;
  static I() { return this._i ??= new BleManager(); }

  private state: ConnectionState = 'idle';
  private devices = new Map<string, Device>();
  private gatt?: ble.GattClientDevice;

  // Business-side subscriptions
  onScan?: (list: Device[]) => void;
  onState?: (s: ConnectionState) => void;
  onNotify?: (opt: { service: string; characteristic: string; value: Uint8Array }) => void;
  onError?: (e: { tag: string; err: unknown }) => void;

  private setState(s: ConnectionState) {
    this.state = s;
    this.onState?.(s);
  }

  /** Start scanning */
  async startScan() {
    try {
      if (this.state === 'scanning') return;
      this.devices.clear();

      // Listen for scan results (BLEDeviceFind returns a list of ScanResult)
      ble.on('BLEDeviceFind', (results: Array<ble.ScanResult>) => {
        for (const it of results ?? []) {
          const id = it.deviceId;
          this.devices.set(id, {
            deviceId: id,
            name: it.deviceName,
            rssi: it.rssi,
            advData: it.advData
          });
        }
        this.onScan?.(Array.from(this.devices.values()));
      });

      // Start scanning (provide filters if needed)
      await ble.startBLEScan(); // Some versions use ble.startScan(filters)
      this.setState('scanning');
      console.info('[BLE] scanning started');
    } catch (err) {
      this.onError?.({ tag: 'startScan', err });
    }
  }

  /** Stop scanning */
  async stopScan() {
    try {
      await ble.stopBLEScan();
      ble.off('BLEDeviceFind'); // Unsubscribe
      this.setState('idle');
      console.info('[BLE] scanning stopped');
    } catch (err) {
      this.onError?.({ tag: 'stopScan', err });
    }
  }

  /** Connect to device */
  async connect(deviceId: string) {
    try {
      await this.stopScan().catch(() => {});
      this.setState('connecting');

      // Create GATT client and connect
      this.gatt = ble.createGattClientDevice(deviceId);
      await this.gatt.connect();   // Some versions return a Promise; others are callback-based
      this.setState('connected');
      console.info(`[BLE] connected: ${deviceId}`);
    } catch (err) {
      this.setState('idle');
      this.onError?.({ tag: 'connect', err });
    }
  }

  /** Read characteristic */
  async read(serviceUuid: string, charUuid: string): Promise<Uint8Array | undefined> {
    try {
      if (!this.gatt) throw new Error('Gatt not ready');
      const value: Uint8Array = await this.gatt.readCharacteristicValue({
        serviceUuid, characteristicUuid: charUuid
      } as any);
      console.info(`[BLE] read ${serviceUuid}/${charUuid} -> ${value?.length ?? 0}B`);
      return value;
    } catch (err) {
      this.onError?.({ tag: 'read', err });
    }
  }

  /** Write characteristic (choose Write/Write NoRsp by need) */
  async write(serviceUuid: string, charUuid: string, payload: Uint8Array, noRsp = false) {
    try {
      if (!this.gatt) throw new Error('Gatt not ready');
      await this.gatt.writeCharacteristicValue({
        serviceUuid,
        characteristicUuid: charUuid,
        value: payload,
        writeType: noRsp ? 1 : 0  // Example: replace with actual enum
      } as any);
      console.info(`[BLE] write ${serviceUuid}/${charUuid} ${payload.length}B`);
    } catch (err) {
      this.onError?.({ tag: 'write', err });
    }
  }

  /** Subscribe/unsubscribe notifications */
  async subscribe(serviceUuid: string, charUuid: string, enable: boolean) {
    try {
      if (!this.gatt) throw new Error('Gatt not ready');
      await this.gatt.setCharacteristicChangeNotification({
        serviceUuid, characteristicUuid: charUuid, enable: enable
      } as any);
      if (enable) {
        this.gatt.on('characteristicChange', (res: any) => {
          const value: Uint8Array = res?.characteristic?.value ?? res?.value;
          this.onNotify?.({ service: serviceUuid, characteristic: charUuid, value });
        });
      } else {
        this.gatt.off('characteristicChange');
      }
      console.info(`[BLE] notify ${enable ? 'ON' : 'OFF'} for ${charUuid}`);
    } catch (err) {
      this.onError?.({ tag: 'subscribe', err });
    }
  }

  /** Disconnect and cleanup */
  async disconnect() {
    try {
      if (this.gatt) {
        await this.gatt.disconnect();
        this.gatt.close?.();
      }
      this.gatt = undefined;
      this.setState('idle');
      console.info('[BLE] disconnected');
    } catch (err) {
      this.onError?.({ tag: 'disconnect', err });
    }
  }

  /** Device list & state */
  getState() { return this.state; }
  getDevices() { return Array.from(this.devices.values()); }
}

Why this structure?

Use the BLEDeviceFind event for scan results; remember to off when stopping.
Connect via createGattClientDevice(deviceId) + connect(), which matches official usage.
Interactions rely on GATT: read/write/subscribe (notifications). Method names/params vary by version; always defer to the API reference. The overall approach remains: identify service/characteristic → read/write/subscribe.
Unified error callbacks and key logs make packet capture and production debugging easier. Best practices emphasize “reasonable Bluetooth usage” and foreground/background policies.

Tip: If your peripheral uses a custom GATT profile, align the Service/Characteristic UUIDs and payload protocol up front — it makes the client side much smoother.

5 ways to get real productivity from Claude Code

Make it read docs first: include @harmony-os-docs/... paths in your prompt and ask for citations.
Ask for a “design doc” up front: folder layout + state machine + event flow + key API mapping table.
Call out version differences: require an “API version matrix”, e.g., startBLEScan vs startScan, and mark “verify on local SDK” where uncertain.
Auto-generate tests/stubs: request quick cases with mocked callbacks/notifications, covering reconnect, permission denial, etc.
Log protocol: agree on a [BLE] prefix + key fields for easy collection; follow “reasonable Bluetooth usage” best practices for scan window and frequency.

In short: feed Claude the docs and tell it to write ArkTS code by the book. You own the boundaries, state, and debugging. In an afternoon, you can have a runnable BLE manager. Thoughts? Share your device model and pitfalls in the comments — I can help with parameters and debugging strategies.

Anthropic (Claude Code’s Parent) Completes $10B Funding Round: An Analysis

Sep 4, 2025

Vibe Sparking

Anthropic has emerged as a prominent player in artificial intelligence. Its core vision is to build AI systems that are trustworthy, interpretable, and controllable—and to lead a “safety‑first race.” Unlike many peers, Anthropic’s story did not begin with a single technical breakthrough but with a deep philosophical and governance split. From day one, it has treated AI safety and ethics as a foundational mission, embedding them into the company’s legal structure, technical methodology, and commercial strategy.

Part I: Origins of a Safety‑First Mission

Born of a split: OpenAI’s philosophical rift

Anthropic was founded in 2021 by a group of former OpenAI employees, led by siblings Dario Amodei (former VP of Research at OpenAI) and Daniela Amodei (former VP of Safety and Policy). In late 2020, they left OpenAI with five colleagues due to fundamental disagreements over the company’s direction.

Dario and others were concerned about OpenAI’s 2019 transition from a non‑profit to a “capped‑profit” entity and its deep partnership with Microsoft. They believed this shift moved the mission from “benefiting all of humanity” toward commercialization and profit, relegating AI safety and ethics to a secondary role. As Dario put it, they “could foresee the exponential growth of artificial intelligence,” and AI companies urgently needed “a set of values to constrain these powerful programs.” The founding of Anthropic was a direct counter to what they saw as sacrificing safety for commercial priorities.

Public benefit corporation: writing the mission into the charter

Anthropic is a Delaware public benefit corporation (PBC). This legal structure requires the company to balance shareholder interests with a public‑benefit purpose. For Anthropic, that purpose is to develop AI systems that are reliable, interpretable, and controllable.

To prevent commercial pressure from eroding its safety mission, Anthropic established the Long‑Term Benefit Trust, which holds a special T‑class of shares and can elect a majority of the board. This governance design aims to legally insulate the safety mission—at least in part—from purely financial interests, addressing the limitations of traditional corporate governance in confronting potential catastrophic risks from AGI.

From the founders’ departures to the company’s structural design, Anthropic’s core narrative is clear: rapid AI progress requires a mission‑driven governance paradigm. This not only builds a “responsible” brand but also offers a credible choice for those concerned about AGI’s commercialization risks.

Part II: Claude’s Architectural Philosophy

Anthropic’s uniqueness lies not only in governance but in its technical methodology, centered on directly addressing the alignment problem.

Constitutional AI: encoding values

Constitutional AI (CAI) aims to train AI to be “helpful, honest, and harmless.” Its core idea is to introduce a human‑written “constitution”—a set of principles that guide the model to self‑critique and revise its outputs during training. Unlike the common approach of deflecting or blurring sensitive topics, CAI enables more direct responses under principled constraints and requires the model to explain refusals when appropriate.

Training occurs in two stages. In supervised fine‑tuning, the model critiques and corrects its own problematic answers using constitutional principles, producing a “less harmful” dataset for further tuning.

Reinforcement learning from AI feedback (RLAIF): an engine for scalable alignment

The second stage uses reinforcement learning. Anthropic applies RLAIF: the model generates two candidate answers, then evaluates and selects a preferred one according to a randomly chosen constitutional principle; these judgments train a preference model so the final policy better adheres to the constitution.

Compared with the more common RLHF, Anthropic argues RLAIF is more efficient and scalable (less dependent on human labeling), improves interpretability and transparency by expressing goals in natural language, and somewhat reduces human bias. Critics note the constitution is still human‑written and thus subjective, and that reducing human intervention raises questions about accountability and oversight. The tension between “automation” and “human control” is central to understanding Anthropic’s approach.

Part III: Evolution of the Claude AI Series

From research to frontier models: a fast timeline

Since launching Claude 1 in March 2023, Anthropic has iterated rapidly on a roughly 4–8 month cadence: Claude 2 (July 2023), the Claude 3 family (March 2024), and beyond—demonstrating that Anthropic is both a research organization and a product company competing at the frontier.

Each generation pushed forward on context length, reasoning, and multimodality: from Claude 2’s 100K‑token context window to Claude 3’s 200K, then toward ~1M tokens in extended reasoning modes with Claude 4. Starting with Claude 3, image+text is supported; coding, math, and logical reasoning improved markedly.

Tiered lineup: covering distinct use cases

Beginning with Claude 3, Anthropic adopted a three‑tier lineup:

Haiku: fastest, for real‑time and low‑latency scenarios.
Sonnet: balanced performance/latency, for general tasks.
Opus: flagship, for complex tasks and advanced reasoning.

Claude 3.5 Sonnet (June 2024) surpassed the larger Claude 3 Opus on several benchmarks, signaling aggressive optimization and productization.

Early exploration of agentic capabilities

Artifacts: introduced with Claude 3.5 Sonnet; generates and previews code, SVGs, websites, and more in a dedicated pane.
Computer Use: debuted in 3.5 Sonnet beta; the AI can operate a virtual desktop, simulating cursor, clicks, and input across applications for multi‑step tasks.
Hybrid Dual‑Mode Reasoning: added in Claude 3.7 and Claude 4; dynamically switches between fast responses and “extended thinking,” invoking tools (retrieval, code execution) when needed.

These capabilities move AI from assistantship toward autonomous agency, while bringing AGI‑related risks closer to the real world.

Table 1: Release timeline and core capabilities of Claude

Model	Release date	Key capabilities/notes
Claude 1	Mar 2023	Initial launch; assistant prototype
Claude 2	Jul 2023	Industry‑leading 100K‑token context
Claude 3 family (Haiku, Sonnet, Opus)	Mar 2024	Tiered lineup; text+image; strong benchmarks
Claude 3.5 Sonnet	Jun 2024	Major gains in coding and chart analysis; introduced “Artifacts”
Claude 3.7 Sonnet	Feb 2025	Hybrid reasoning; switch between fast/deep modes
Claude 4 family (Sonnet 4, Opus 4)	May 2025	~1M‑token context (extended reasoning); improved Computer Use and Working Notes

Part IV: Commercial Practice of Safe AI — Growth, Capital, and Partnerships

Ascent in capital markets

Anthropic’s valuation exceeded $61B by late 2024 and reached roughly $183B after its Series F in mid‑2025. The latest $13B round led by ICONIQ further strengthens its position across enterprise, developer, and premium consumer markets.

Revenue has grown rapidly as well: annualized run‑rate rose from about $1B in early 2025 to over $5B by August. Claude Code alone reached more than a $0.5B annualized run‑rate within three months, showing clear conversion from technology to competitive advantage.

Strategic alliances with tech giants

Anthropic forged deep partnerships with Amazon and Google: it designates AWS as a primary cloud provider and offers models on Amazon Bedrock; Google has also committed billions in investment and cloud infrastructure support. Access to compute such as Trainium and TPUs enables large‑scale frontier training.

Moral dilemma: lessons from a leaked memo

In 2025, an internal memo by CEO Dario Amodei was leaked, candidly acknowledging that to remain competitive the company had considered seeking investment from Middle Eastern sovereign capital—and recognizing the “moral risk.” He wrote: “I really wish we didn’t have to be in this position, but we are,” and, “‘No bad actor should benefit from our success’ is a hard principle on which to run a business.”

This highlights Anthropic’s core contradiction: in a capital‑intensive race, even governance with public‑benefit features cannot fully escape the pressures of “racing to the bottom.”

Table 2: Anthropic’s major financing rounds and valuation

Date	Investors	Amount	Valuation
Apr 2022	FTX	$580M	Not disclosed
Sep/Oct 2023	Amazon, Google	Amazon committed $4B (first tranche $1.25B); Google committed $2B (first tranche $500M)	>$61B
Mar 2024	Amazon	$2.75B (completing the $4B commitment)	Not disclosed
Nov 2024	Amazon	$4B (total investment reached $8B)	Not disclosed
May 2025	ICONIQ, Fidelity, Lightspeed, etc.	$13B	~$183B

Part V: Outlook — AGI and Societal Impact

The AGI race: an urgent vision

Dario Amodei has expressed an aggressive timeline for AGI, even suggesting a “singularity” could arrive as early as 2026. This urgency helps explain Anthropic’s immense capital needs and the difficult trade‑offs it faces in competition.

Leading a safety‑centric competition

Beyond setting a technical baseline with CAI, Anthropic actively participates in US AI policy discussions. Its collaboration with Palantir brought Claude 3/3.5 into “classified environments” for the first time—both validating capabilities and safety, and touching one of the model’s most controversial application domains.

AI‑driven future: impact and challenges

Products like Claude Code make modern, automated software engineering a practical reality and will drive change across healthcare, education, and finance. Challenges remain: how to ensure systems apply ethical principles robustly in complex contexts; how to build regulatory and accountability frameworks; and how to rebuild public trust.

Conclusion: Anthropic’s Inevitable Choice

Anthropic began with a mission‑driven split and embedded safety into its corporate DNA through a PBC and trust‑based governance. Its rapid iteration and commercial growth suggest that a “safety commitment” can be a powerful market differentiator. Yet the leaked memo reveals persistent tension between capital and ideals.

Building powerful AI and ensuring its safety are not parallel lines but two sides of the same coin. As Anthropic moves forward along this complicated path, it will shape the technical landscape of AI and force us to confront a deeper question: in an AI‑driven world, how much principle are we willing to trade for power?

Claude Code vs Codex CLI — Which Fits Your Daily Dev?

Sep 4, 2025

Vibe Sparking

Claude Code is more mature for engineering workflows (subagents, slash commands, hooks). Codex (GPT‑5 High) is faster, sticks closer to instructions, and gets things done with fewer words. Use both for maximum throughput.

Introduction

The community has been buzzing again about Codex CLI and Claude Code. Someone built a small tool using Cloudflare Workers + Telegram: it watches Codex GitHub releases and pushes new versions to Telegram. Both agents “worked end‑to‑end”, but the experience differed in meaningful ways.

Here’s a practical, ready‑to‑apply comparison to help you choose quickly.

TL;DR Checklist

Engineering/Extensibility: Claude Code wins. Subagents, custom slash commands, and hooks are very mature.
Execution rhythm/plan view: Codex shows more detail in its plan panel; Claude Code defaults to “current task only”, which makes flow feel smoother.
Instruction adherence: Codex (GPT‑5 High) followed explicit constraints (like directory layout) more strictly; in one run it emitted multi‑file /src output, while Opus bundled code into a single worker.js.
Data fetching strategy: Different roads to Rome — Codex used Atom feeds; Claude Code used the GitHub API. Both got the job done.
Observability: Codex provides /status for token use and Ctrl+T to explore conversation history (community is adding export/persistence tooling).
Speed and cost perception: In a single task sample, GPT‑5 used ~90k tokens vs Opus ~50k. Because GPT‑5 is cheaper per token, total cost isn’t necessarily higher. Treat this as an anecdote, not a benchmark.
Docs ecosystem: Claude Code docs feel more systematic; Codex docs are improving quickly.

Why Is Everyone Testing Right Now?

OpenAI is positioning Codex as a full‑field development agent: CLI, IDE extensions, cloud, and GitHub integration in one. It shares state through your ChatGPT account so a task can bounce between local and cloud. The VS Code extension is live — no API key setup, plus cloud sandbox for execution.

The release cadence is fast, so media and community reviews are everywhere.

Head‑to‑Head: Findings from a Cloudflare Worker Field Test

1) Engineering Capability: Claude Code Feels Like an Orchestratable Platform

Subagents: Split roles and context with separate system prompts, tools, and isolated memory. Great for “data gathering / solution review / scaffold generation” assembly lines.
Slash commands: Expose MCP‑discovered commands and build a team‑level action library inside your project.
Hooks: Force lifecycle actions (session start, before/after tool exec) to run every time. Think “lint → test → commit” guaranteed, not subject to model mood.

Bottom line: If you need scale and control, Claude Code’s orchestration is a clear advantage.

2) Execution Experience: Codex Is Snappier; Claude Code Flows Nicely

Codex is concise, sticks closely to instructions, and moves fast.
Claude Code’s TUI is more mature; the diff views are clear. Defaulting to the current task reduces distractions from long plans.
In one run, Codex had “auto run” selected but still asked for permissions fairly often; Claude Code’s interaction felt steadier.

3) Directory and Architecture Adherence: Codex “Builds to Spec”

Given the same project template and directory constraints:

Codex (GPT‑5 High) produced multi‑file output under /src.
Claude (Opus 4.1) consolidated into a single worker.js.

If you care a lot about rigid layouts, Codex’s strictness is a plus.

4) Data Fetching Strategy: Two Valid Defaults

Codex: prefer Atom feeds — conveniently structured.
Claude Code: call GitHub APIs — richer fields when you need them.

Both yielded what we needed for Telegram publishing; default “info density” differed slightly.

5) Observability and Review

/status to inspect token usage; Ctrl+T for conversation history. Community PRs aim to improve export and traceability.

What to Choose: Best Fit by Persona

You want to “Ship Tonight”

Choose Codex:

Tighter instruction following, fewer pleasantries, default behavior that just works.
VS Code extension + cloud sandbox makes onboarding clean and fast.

You need “Orchestration, Governance, Reuse”

Choose Claude Code:

Subagents for division of labor, slash commands to codify SOPs, hooks to harden workflows.
High reuse in teams; great for complex, multi‑person projects.

You are “Efficiency‑max”

Use both:

Codex to spin up features and validate ideas quickly.
Claude Code to codify process, hook into CI, and build a team command library.

One Page to Compare

Dimension	Codex (GPT‑5 High)	Claude Code (Opus 4.1 exemplar)
Time‑to‑first‑ship	Fast, concise, gets things done	Slightly slower, steadier interaction
Instruction adherence	Strong (sticks to directory/constraints)	Occasionally “helpful” consolidation
Engineering	CLI + IDE + Cloud, improving fast	Subagents / Slash / Hooks are mature
Observability	`/status`, `Ctrl+T`, community tooling rising	Mature diffs, strong task focus
Data fetching	Prefers structured feeds (Atom)	Prefers rich APIs (GitHub)
Docs ecosystem	Improving quickly	More systematic today
Best use case	Rapid features and experiments	Complex projects, governance, team assets

Note: this is based on public docs and a single real test. Details will change with updates.

Practical Workflow: Make It Your Daily Pipeline

Suggested pattern (copy freely):

Use Codex to deliver the MVP: confirm interfaces, directories, and dependencies.
Switch to Claude Code:
- Create a “gathering subagent” to pull context (docs, API constraints, dependency risks).
- Add slash commands for common actions (/lint, /test, /gen-release-notes).
- Configure hooks to enforce pre‑CI actions (pre‑commit checks, tests, semantic versioning, change set generation).
Return to Codex for small iterative features and regression; keep an eye on tokens with /status.

Tip: Codex’s brevity encourages quick iterations; Claude Code’s engineering primitives help turn wins into durable team assets.

Conclusion

This isn’t a “replacement” story. Codex is a sprinter; Claude Code is a triathlete. Use the right one for the job and you’ll find they complement each other perfectly.

Which style do you prefer? Tell us — we’ll keep this comparison updated as a living “selection guide”.

Don’t want Claude Code to feed your code to Anthropic? Use this privacy settings checklist

Sep 4, 2025

Vibe Sparking

TL;DR: For personal accounts (Free/Pro/Max), go to claude.ai → Settings → Data & Privacy and turn off “Use my chats/coding sessions to improve the model.” For organizations/API, usage is not used for training by default; for extra assurance, use Zero Data Retention (ZDR) with an org API key for Claude Code. On your machine, disable Statsig telemetry/Sentry error reporting, don’t use /bug to upload sessions, and periodically clear local caches.

Why lock it down now

Anthropic is updating data policy for consumer products (including Claude, Pro, Max, and Claude Code when signed in with those accounts): you can choose whether chats and coding sessions are used for training; if you choose Allow, the retention period can be up to 5 years. If you choose Do not allow, the service side retains up to 30 days for operations and compliance. This choice only applies to newly created or “resumed” sessions (no retroactive scanning of dormant history). You can change it anytime in Privacy Settings.

For industry coverage and reminders about timing, see summaries from The Verge / Tom’s Guide.

Safest setups for three user types

① Personal users (Free / Pro / Max)

Goal: prevent your chats and code from being used for training.

How to do it

Open claude.ai → Settings → Data & Privacy.
Turn off “Use my chats/coding sessions to improve Claude” (or similar wording).
Remember: this only applies to new/resumed sessions; deleted conversations will not be used for training. You can change this later, but data already used for training cannot be undone.

Retention rules (when you disable training): backend storage for up to 30 days.

② Team / Enterprise / API (commercial products)

Default is safer: Anthropic’s commercial products (Claude for Work, Anthropic API, Claude Gov, etc.) do not use your inputs/outputs for training by default.

Even safer (recommended): sign Zero Data Retention (ZDR) and use your organization’s API key in Claude Code. ZDR currently applies only to the Anthropic API and products that use your org API key (including Claude Code).

Default retention: on the API side, 30‑day auto‑deletion (if ZDR isn’t in place and absent additional legal/risk requirements).

③ Go via cloud providers (Bedrock / Vertex) for another layer of isolation

AWS Bedrock: explicitly does not use your inputs/outputs to train models; contract terms also constrain third‑party models (including Anthropic).
Google Vertex AI: has dedicated data governance and caching docs; enterprises can configure to meet compliance and minimize retention (read caching/governance details carefully).

This “cloud‑side isolation” suits highly regulated sectors, keeping orchestration, logs, and KMS within your cloud account under unified governance.

Local hardening you must do for Claude Code

These are the most commonly overlooked steps in “keep it private” practice; once done, you’ll be much more at ease.

A. Disable telemetry and error reporting (keep runtime metrics local)

Officially supported environment variables (cross‑platform example):

# Disable Statsig telemetry (does not include code/file paths)
export DISABLE_TELEMETRY=1

# Disable Sentry error reporting
export DISABLE_ERROR_REPORTING=1

# Disable the /bug command (does not include code/file paths)
export DISABLE_BUG_COMMAND=1

# Disable all non‑essential network requests (more thorough)
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

You can also write these under the env node in ~/.claude/settings.json, and override per‑project via .claude/settings.local.json.

  "env": {
    "DISABLE_TELEMETRY": "1",
    "DISABLE_ERROR_REPORTING": "1",
    "DISABLE_BUG_COMMAND": "1",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  }

B. Avoid bundling full sessions for upload (don’t casually use `/bug`)

The official recommendation is to use /bug to submit issues; it bundles context for Anthropic to diagnose. Therefore avoid it when dealing with sensitive repos/code.
The community has collected an env var to disable /bug (DISABLE_BUG_COMMAND=1). This is “unofficial / may change” — for reference only.

C. Local caches and session files

Per official notes, the client can cache sessions locally for up to 30 days to aid resuming (configurable). In sensitive environments, regularly clean ~/.claude/ and set cache duration to a minimum.
The community has previously reported issues about .claude.json retaining conversation fragments — these are behavioral reports, not official guarantees. Add .claude/ to your security baseline and backup exclusion lists.

A “belt‑and‑suspenders” playbook (copy as‑is)

Personal accounts (must‑do)

Turn off “Use to improve the model.”
Periodically clean ~/.claude/; before using /bug, do redaction/sanitization.
Set: DISABLE_TELEMETRY=1, DISABLE_ERROR_REPORTING=1.

Teams/enterprises (strongly recommended)

Only log into Claude Code with your org API key; sign ZDR if possible.
Inject the “no‑upload” env vars (Section A) centrally across servers and CI/CD.
Prefer Bedrock/Vertex routes; implement cloud‑side DLP/KMS and access auditing.

Common pitfalls to avoid

Myth 1: “If I delete historical chats, they won’t be used for training.” → After deletion, they won’t be used for training, but whether they were trained on depends on your setting at the time; training is irreversible.
Myth 2: “Using Claude Code equals enterprise‑grade protection.” → It depends on the account and key you use. Claude Code signed in with a personal account is still under consumer terms.
Myth 3: “If I go via Bedrock/Vertex, I’m done.” → You still need to configure your own permission boundaries, key management, logging policies, and cache governance. The docs are explicit.

Closing

Data privacy has never been a simple on/off switch. It’s a set of habits: right configuration + right tools + team discipline. Work through the checklist above and your code and conversations will not be shared with Anthropic for training, while you also preserve your team’s compliance boundary.

Claude Code 1.0.9x: Permission Doctor, Direct Memory Editing, Vertex Global Endpoints, and More

Sep 3, 2025

Vibe Sparking

A fast series of 1.0.90–1.0.97 updates lands several practical fixes and upgrades: permission rule validation, editable memory files, Vertex global endpoints, proxy compatibility, hot‑reloaded settings, and a task list. The execution loop feels much tighter for engineers.

Introduction

Over the past two weeks, Claude Code shipped multiple minor versions. They look small, but each one targets high‑frequency operations: no more fragile permission rules, edit memory files directly, route Vertex via a global endpoint for higher availability, paste images easily on Windows, and see settings take effect immediately. Below is a hands‑on rundown of the most impactful changes, with copy‑ready usage.

What’s New (1.0.90–1.0.97)

1.0.97: /doctor adds permission rule syntax validation with fix suggestions. No more losing time to a stray parenthesis or wildcard.
1.0.94:
- Vertex supports a global endpoint, improving cross‑region availability.
- /memory can now open and edit all imported memory files directly, making team guidance easier to organize.
- SDK adds support for custom tools as callbacks (in‑process MCP / callback hooks), making it easier to plug your own tools into the agent loop.
- New /todos lists the current task set, helping the plan → act → verify loop feel natural.
1.0.93:
- Windows adds Alt + V to paste images from clipboard for fast inclusion of error screenshots and sketches.
- Supports NO_PROXY to bypass specific hosts/subnets (with HTTP(S)_PROXY)), better for enterprise networks or custom proxy setups.
1.0.90: Settings changes apply immediately with no restart. Note: hooks are an exception (details below).

Quick version check:

npm i -g @anthropic-ai/claude-code

claude update
#
claude -v   # should show 1.0.9x+

01 No more guesswork: use `/doctor` for permission checks (1.0.97)

Permissions are your brakes and throttle in Claude Code. Writing allow/deny used to be error‑prone; now just run:

/doctor

It will validate syntax, point out issues, and provide fix suggestions. For example, if you wrote:

{
  "permissions": {
    "allow": ["Bash(git commit:*)", "Edit", "ReadFile:*"],
    "deny": ["Bash(rm -rf *)"]
  }
}

/doctor can surface wildcard correctness, priority overlaps, and more. This is essential for a shared, unified “allowed commands” policy across teams.

Security note: the community has reported cases where deny rules didn’t take effect or command chains found bypasses. Don’t over‑grant at the start—prefer least privilege and open up gradually.

02 Team memory, edited in place: `/memory` (1.0.94)

/memory now does more than show loaded CLAUDE.md files—it lets you open and edit them directly (including multi‑level imports via @path/to/file). Benefits:

One change, shared impact: Put conventions in the repo so the whole team benefits.
Modular structure: Use @imports to manage layers for architecture, Git rules, scaffolding commands, etc.
Rapid iteration: Works great with hot‑reloaded settings.

Command:

/memory      # view & edit project/personal/org CLAUDE.md

The official docs outline imports, multi‑level discovery, and org‑level paths—strongly recommended to formalize in your repos.

03 Vertex global endpoint: steadier cross‑region routing (1.0.94)

If you’re billed via Google Vertex AI, you can now use the global endpoint to route to available regions dynamically, improving availability and stability. Great for overnight long jobs or “must‑pass” CI before submission. Docs confirm Claude Code supports both global and regional endpoints for Vertex.

Tip: available models and aliases can vary by region. When switching, double‑check the endpoint ↔ model mapping.

04 Settings hot‑reload, with a hooks caveat (1.0.90)

From 1.0.90, most settings apply immediately—no session restart needed. This tightens the tweak → retry loop.

Exception: Hooks (pre/post execution) are not replaced immediately. The current session uses a startup snapshot; after editing hooks, open /hooks to review & apply. Don’t miss this detail.

05 Enterprise‑friendly: NO_PROXY & paste images (1.0.93)

NO_PROXY support: In complex intranet / multi‑hop proxy setups, directly connect to certain hosts or subnets and bypass the global proxy. Used with HTTP_PROXY/HTTPS_PROXY, this fits CI and bastion/egress scenarios well.
Windows Alt + V: Paste images directly in the terminal, ideal for embedding error screenshots/tables into context to speed up “locate → fix”.

06 SDK callbacks & custom tools: wire in your pipeline (1.0.94)

The TypeScript SDK supports an in‑process MCP server and custom tools, so “build, lint, pre‑publish checks, canary rollback,” etc. can become tools Claude calls. Combine with callbacks/hooks to stitch together success/failure handling and audit logs.

Quickstart checklist (copy‑ready)

1) Check permissions

/doctor
/permissions           # view current allow/deny
/config                # open settings panel

2) Layer your memory

@docs/architecture.md
@docs/git.md
@~/.claude/personal-rules.md

/memory                # edit the above files directly

3) Vertex global endpoint (illustrative)

Switch your environment to a global endpoint as per GCP docs and available models. Confirm exact endpoints and regional model support with the official documentation.

4) Enterprise proxy

export HTTPS_PROXY=http://user:pass@proxy.example.com:8080
export NO_PROXY=localhost,127.0.0.1,.corp.example.com

Conclusion

This 1.0.9x batch isn’t flashy, but each change boosts real‑world delivery: steadier permissions, easier memory management, better network availability, smoother settings, and a handy task list.

If you’re rolling out “agent‑style development” to a team, prioritize hardening permissions and memory structure first—the payoff is immediate.

Which update helps you the most? Share your practice in the comments.

Claude Code CLI Config Playbook

Sep 3, 2025

Vibe Sparking

Want Claude Code to feel snappy, steady, and fast? Here’s a paste-and-go cheat sheet for claude config plus practical templates your team can adopt immediately.

This is a hands-on playbook: copy commands as-is, drop in configs, troubleshoot quickly. Sources are noted so you can share confidently with teammates and IT.

Why configure it properly?

Save time: set model, permissions, and env once; fewer round trips.
Reduce friction: enterprise policy, project defaults, and personal prefs stop clashing.
Safer by default: blacklist sensitive files and dangerous commands to avoid “oops” moments.

1) How to use `claude config`

Most of the time you’ll need these (supports -g/--global for global scope):

# List all settings
claude config list

# Read one key
claude config get <key>

# Set one key
claude config set <key> <value>

# Append/remove for list-like settings
claude config add <key> <value>
claude config remove <key> <value>

# Examples: set global theme & project default model
claude config set -g theme dark
claude config set model claude-sonnet-4-20250514

Official docs list these subcommands and explain the scope of -g/--global.

2) Where do settings live? Which one wins?

Priority from highest to lowest:

Enterprise managed policy (cannot be overridden)
- macOS: /Library/Application Support/ClaudeCode/managed-settings.json
- Linux/WSL: /etc/claude-code/managed-settings.json
- Windows: C:\\ProgramData\\ClaudeCode\\managed-settings.json
CLI arguments (temporary for current invocation)
Project local: .claude/settings.local.json (personal, git-ignored)
Project shared: .claude/settings.json (team-shared)
User global: ~/.claude/settings.json (personal default)

The official Settings page documents paths, precedence, and examples using consistent terminology for IT.

3) The 8 most useful settings

1) Theme & output style

claude config set -g theme dark
claude config set -g verbose true

Both theme and verbose are built-in. verbose defaults to false.

2) Default model (4 ways, by precedence)

CLI argument: claude --model <alias|name>
In-session: /model sonnet
Env var: export ANTHROPIC_MODEL=opus
Settings file: "model": "claude-sonnet-4-20250514"

Suggested combo (practical):

# Global default: balanced
claude config set -g model claude-sonnet-4-20250514

# For expressive tasks on demand
claude --model opus

Official docs clarify precedence and examples; include this in your team README to avoid arguments.

3) Disable nonessential traffic (privacy/intranet)

# Three options: settings.json, global env, or one-off env
claude config set -g env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC 1

echo 'export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1' >> ~/.zshrc
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 claude

This env var is equivalent to setting all of: DISABLE_AUTOUPDATER, DISABLE_BUG_COMMAND, DISABLE_ERROR_REPORTING, and DISABLE_TELEMETRY.

4) Don’t add “Co-authored-by Claude” to commits

claude config set includeCoAuthoredBy false

includeCoAuthoredBy is officially supported and defaults to true.

5) Task-complete notifications (long tasks)

claude config set -g preferredNotifChannel terminal_bell

See “Terminal configuration” in docs. On macOS, ensure terminal notifications are allowed.

6) Project permissions allow/deny lists (highly recommended)

{
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test:*)",
      "Read(~/.zshrc)"
    ],
    "deny": [
      "Bash(curl:*)",
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)"
    ]
  }
}

permissions.allow/ask/deny is the new mechanism replacing ignorePatterns; great for hard-blocking secrets.

7) Status Line: show model, branch, cost hints

{ "statusLine": { "type": "command", "command": "~/.claude/statusline.sh" } }

You can also try /statusline to have Claude scaffold a starter script.

8) Enterprise-wide policy (compliance must-haves)

Use managed-settings.json to enforce permissions/tools.
Disable bypass mode so sensitive actions always require confirmation:

{
  "permissions": {
    "defaultMode": "acceptEdits",
    "disableBypassPermissionsMode": "disable"
  }
}

Enterprise policy paths and permission controls are documented in the official Settings guide.

4) Five plug-and-play team templates

Template A | Privacy-first on corporate networks

# Disable nonessential traffic, error reporting, /bug, and auto-updates
claude config set -g env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC 1
claude config set -g theme dark
claude config set -g verbose true
claude config set -g model claude-sonnet-4-20250514

See the Environment Variables table for meanings and equivalents.

Template B | Frontend project (safe allowlist)

claude config add permissions.allow "Bash(npm run dev)"
claude config add permissions.allow "Bash(npm run test:*)"
claude config add permissions.deny  "Read(./.env)"
claude config add permissions.deny  "Read(./secrets/**)"

Allow test-related commands; deny reading .env and anything under secrets.

Template C | Backend project (cost control)

# Keep a balanced default; switch to Opus only when necessary
claude config set -g model claude-sonnet-4-20250514
# In-session: /model opus

Model precedence follows “Model configuration”: CLI > env var > settings file.

Template D | Long task notifications

claude config set -g preferredNotifChannel terminal_bell

Terminal bell works well for CI or scaffolding workflows.

Template E | No automatic “Co-authored-by” in PRs

claude config set includeCoAuthoredBy false

Use when your team policy avoids AI co-authoring in commit messages.

5) Common pitfalls (and quick fixes)

“Why didn’t my change take effect?” Check precedence. Enterprise > CLI arg > project local > project shared > user. Higher levels can override.
“I want to disable all telemetry/reporting/auto-update at once.” Use CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 to cover all four switches.
“Where do I put the settings file?” User: ~/.claude/settings.json; Project: .claude/settings(.local).json; Enterprise: system-level managed-settings.json (see platform paths above).

Closing thoughts

Rollout in three steps:

Decide who wins (precedence & policy) → Decide what’s allowed (permissions allow/deny) → Decide how it behaves (model, output, notifications, env).

With the right setup, Claude Code becomes your team’s AI dev muscle memory: steadier, faster, safer. One set of templates, tailored per project, without friction.

References

CLI Reference: https://docs.anthropic.com/en/docs/claude-code/cli-reference
Settings: https://docs.anthropic.com/en/docs/claude-code/settings
Model configuration: https://docs.anthropic.com/en/docs/claude-code/model-config
Terminal configuration: https://docs.anthropic.com/en/docs/claude-code/terminal-config
Status line: https://docs.anthropic.com/en/docs/claude-code/statusline

Discussion prompts

Does your team prioritize stricter permissions or faster iteration? How will you balance both?
Which three rules will you enforce via enterprise policy for everyone?

Claude Code Best Practices: The Prototyping Method

Sep 2, 2025

Vibe Sparking

First, use Claude Code to quickly “get a prototype working” to refine the requirements; then, return to engineering design and implementation to ensure quality and stability. Efficiency and quality, we want both.

Introduction

The hardest part of product development isn’t writing code. It’s clearly defining “what needs to be built.”

That’s why I recommend this two-stage approach: Build a prototype in the first version, and handle the engineering seriously in the second. Claude Code is well-suited for this strategy: it works alongside you in the terminal, handling the grunt work first, allowing you to refine it later.

The 2 Stages of the Prototyping Method

Stage 1: Prototype Only, Aim for “It Works”

Goal: Get the feature running to make the requirements tangible.
Ignore: Design, performance, security, code quality.
Method: Use throwaway code, letting the AI take the lead to quickly explore feasible paths (similar to “Spike/Throwaway Prototyping”).

Why this approach? Because many ambiguities are only exposed when the code is running. Screenshots, GIFs, and clickable prototypes are far more useful than a ten-page requirements document.

Claude Code’s advantages in this stage:

Directly read, modify, and run code within your local project—conversation becomes action.
Frequent actions can be turned into Slash Commands for one-click reuse, like “start backend + mock data + run locally.”

A word of caution: If you’re using a personal subscription, Anthropic recently introduced an opt-in mechanism for data training that includes Claude Code sessions. Check your privacy settings before prototyping company projects.

Stage 2: Redesign and Engineer Seriously

Trigger: Requirements are mostly finalized, and the scope is stable.
Deliverables: Database schema, API contracts, state management, module boundaries, testing strategy, etc.
Pace: Human-led, AI-assisted. You set the design anchors, and the AI builds according to the plan.

How to use Claude Code in this stage:

Let it scaffold the project, add boilerplate, and write tests based on your design.
@claude in PRs/Issues to automatically create PRs and fix minor issues (via GitHub Actions integration).
Write engineering conventions into a CLAUDE.md file or Slash Commands to ensure the AI follows project rules.

Security/Non-Functional Advice: Treat security, performance, and maintainability as “Technical Enablers” and progressively incorporate them into your Definition of Done (DoD) during the second stage. Conduct Spikes for validation when necessary.

When Can You Skip the Prototype?

The requirements have already been validated (e.g., redoing an old feature, a clear competitor to model after).
The primary risk is in the engineering implementation, not the product definition. In this case, you can proceed directly to Stage 2: Design and Implementation, with Claude Code acting as a scaffolding and execution tool.

Field Guide: My Recommended Uses in Daily Development

Here are practical checklists for prototyping to engineering across four common scenarios.

Example A: Growth Experiment Landing Page (Next.js)

Prototype Version (Half a day)

Have Claude Code generate a minimal page, tracking events, and a form that submits to /api/echo.
Get it running with mock data and simple A/B test parameters.

# Prototype: generate page + mock API + run dev server
claude "/proto nextjs landing with /api/echo and ab flags; run dev"

Engineered Version

Design the routing and data models, and agree on event names for tracking.
Generate OpenAPI specs or protocol documents; write unit/contract tests; integrate the Claude Code Action in CI for automated checks and fixes.

Example B: Mini-Program / BLE Device Data Collection

Prototype Version

Prioritize getting the scan → connect → read → local cache flow working, ignoring exception handling.
Use Slash Commands to quickly reuse build and on-device debugging commands.

Engineered Version

Define the state machine (connected/disconnected/reconnecting/timeout).
Design the offline synchronization protocol and replay strategy; add boundary tests.
Create a /test-ble-reconnect command for fault injection and recovery.

Example C: Internal Approval System (Rails/React)

Prototype Version

Focus only on the core workflow: submit, route, approve/reject.
Use an in-memory store or SQLite; don’t implement permissions yet.

Engineered Version

Design the RBAC and audit log table structures; write migration scripts.
Add rate limiting, audit export, and SLO reporting; let Claude Code automatically fix minor issues and add tests in PRs.

Example D: Data Service (FastAPI + DuckDB)

Prototype Version

Start with three read-only APIs for different scenarios, returning static or semi-dynamic data.
Ignore caching and permissions to get the frontend unblocked.

Engineered Version

Define the pagination/sorting/filtering protocol and error codes; add authentication.
Add a caching layer and rate limiting; create a /bench-api command to run load tests against a baseline.

Claude Code’s “Metronome”

Interactive terminal + command line allows for high-frequency iteration by chatting and modifying files.
Slash Commands solidify your “operational playbooks” for team sharing.
GitHub Actions bring @claude into PRs/Issues for automatic patching, PR generation, and enforcing project standards.

Together, these three features create a fast track from “idea → prototype → engineered product.”

Common Pitfalls and My Evasions

Prototype drags on for too long: If requirements aren’t settled in 1-2 weeks, break it down into smaller stories; conduct a Spike summary if needed.
Prototype code accidentally shipped to production: Use branch isolation, directory prefixes like /proto-*, and CI checks to block it.
Unbounded second stage: Write an Engineering DoD (including security and performance), list non-functional items as Technical Enablers, and complete them sprint by sprint.
Privacy compliance: Prioritize enterprise/API channels for company projects; for personal subscriptions, always check data training opt-in settings.

Conclusion

Prototyping isn’t about being lazy; it’s about accelerating clarity. Engineering isn’t about being slow; it’s about reducing long-term costs.

With Claude Code, we can put these two activities in their proper place: AI leads the prototyping, humans lead the engineering. Take that hesitant requirement you have right now, and just get it running.

What do you think? Does your team get stuck more in the prototyping or engineering phase? Let’s discuss in the comments.

One‑Click Provider Switching for Claude Code & Codex with CC‑Switch

Sep 2, 2025

Vibe Sparking

TL;DR Want to quickly switch between different providers for Claude Code and Codex — DeepSeek / Qwen Coder / GLM / Kimi K2 / packycode, etc.? CC‑Switch is an ultra‑light desktop app built on Tauri 2.0 (installer ~5 MB). It supports one‑click switching, import current config as default, switching back to official sign‑in, and automatic backups. The new v3.1.0 adds Codex provider management and one‑click switching.

Introduction: Why do you need a “one‑click provider switcher”?

As people who write code every day, we’re often more like dispatchers of cost and speed. Today you use Qwen Coder for speed; tomorrow you switch to DeepSeek v3.1 for complex reasoning; when compatibility issues show up, you switch back to Claude official sign‑in. If you still have to manually edit configs under ~/.claude and ~/.codex every time, it’s annoying and error‑prone.

CC‑Switch turns this into a single toggle: Click once, and the provider switches. Config copies are auto‑managed, rollback is safe, and you can return to official sign‑in at any time.

Highlights at a glance

Truly lightweight: Built on Tauri 2.0, launches instantly. The official guidance emphasizes Tauri’s small‑footprint approach (more restrained than Electron). In v3.0.0, CC‑Switch migrated from Electron to Tauri 2.0. In author tests the bundle size dropped from ~80 MB to ~12 MB and startup sped up 10×.
Supports both Claude Code and Codex:
- Claude Code primary config: ~/.claude/settings.json (or legacy claude.json) The official docs confirm ~/.claude/settings.json is the standard entry point.
- Codex primary config: ~/.codex/auth.json (required) + ~/.codex/config.toml (may be empty) The Codex README also states ~/.codex/config.toml is the config center, supporting MCP, etc.
One‑click switch & automatic backups: Switching overlays the selected provider copy onto the primary config. If there’s a provider currently “in use”, CC‑Switch first writes the primary config back into that provider’s copy to facilitate rollback. Internal config v1→v2 migrations are timestamp‑backed up under ~/.cc-switch/.
Presets ready to use: DeepSeek v3.1, Qwen Coder, GLM, Kimi K2, packycode… just paste a key to configure with one click.
Switch back to official sign‑in anytime: Prefer Claude or Codex’s official sign‑in? Add the Official Sign‑In preset. After switching, restart your terminal to use /login (Claude Code) or “Sign in with ChatGPT” (Codex side).
Privacy‑friendly: Everything is stored locally only in ~/.cc-switch/config.json.

Installation and system requirements

Supports Windows / macOS / Linux:

Windows: Download CC-Switch-Setup.msi or Windows-Portable.zip from Releases.
macOS: Download CC-Switch-macOS.zip. On first launch you may see an “unidentified developer” warning; go to System Settings → Privacy & Security → “Open Anyway”.
Linux: Download the .deb package.

Heads‑up: The author doesn’t have an Apple Developer account, so the first launch may be blocked; follow the steps above to allow it.

Quick start: 3 steps to switch providers

Add a provider Click “Add Provider”, pick a preset or define your own, and enter the API Key. (When using an API key with Codex, OPENAI_API_KEY is common. If you’re using official account sign‑in, switch to “Codex Official Sign‑In”.)
One‑click switch Check the provider you want in the list, then click the radio button. CC‑Switch overlays the copy onto the primary config:

Codex: overlays ~/.codex/auth.json and ~/.codex/config.toml (creates an empty config.toml if missing).
Claude Code: overlays ~/.claude/settings.json (or legacy claude.json).

Restart or open a new terminal Open a new terminal tab or restart your terminal so the CLI picks up the latest config. Claude Code’s docs also recommend restarting for a cleaner flow when using /login.

Three recommended usage patterns (practical)

A. “Preset in seconds” daily flow

Set DeepSeek v3.1 as default. For frontend refactors or large‑file analysis, switch to Qwen Coder with one click; for complex reasoning, switch back to DeepSeek. No hand‑editing configs at any point.

B. “Import as default” smooth migration

Already using Codex or Claude Code? CC‑Switch automatically imports your current primary config as the default provider copy so you always have a “home base” to return to.

When debugging goes sideways or quota is tight, switch back to Claude official sign‑in or Codex Sign in with ChatGPT. Avoid detours and get things done first.

Details and edges: pitfalls you might hit

Codex config files The community tends to use ~/.codex/config.toml, but some mention historical versions/installs leading to different filenames or missing files (e.g., only seeing config.json). During switching, CC‑Switch creates an empty config.toml as a fallback to keep things consistent.
Claude Code’s official path Official docs state the user‑level config is ~/.claude/settings.json. If your older environment still uses claude.json, CC‑Switch supports that too.
Privacy and security CC‑Switch only modifies local files and does not send anything to a server. For team sharing, manage project‑level .claude/settings.json etc. with Git yourself (Claude Code also supports project‑level settings).

Compared to alternatives

There are command‑line tools for provider switching, but CC‑Switch’s GUI plus “copy strategy” is more intuitive and robust.
If you want minimalism, visualization, and one‑click fallback to official sign‑in, it’s a great “always‑on helper.” (It complements CLI/scripts.) (Reference: There are similar community tools and posts, but CC‑Switch focuses more on “GUI + dual ecosystems”.)

FAQ

Q1: If switching fails, can I roll back? Yes. The currently “in‑use” primary config is first backed up to that provider’s copy, so you can switch back to it anytime.

Q2: Codex keeps asking me to sign in or says the config is invalid. Prefer “Codex Official Sign‑In” (Sign in with ChatGPT) first, or confirm OPENAI_API_KEY and OPENAI_BASE_URL are in the correct places within auth.json/config.toml.

Q3: Why is the app so small and fast to start? Because Tauri bundles only the necessary native shell and frontend assets; the official guides emphasize the small‑bundle approach. After migrating to Tauri 2.0, the reported improvements are significant.

Conclusion

Turn “switching providers” into a single click, and you can focus on what really matters: writing the right code and making the right decisions. For people who collaborate across models, CC‑Switch is like a gear shifter on your desktop — handy, reliable, and fast. Give v3.1.0 a spin and let your multi‑provider workflow take off.

Three-Model Playbook for Faster Software Delivery

Aug 31, 2025

Vibe Sparking

Gemini for discovery → ChatGPT for planning and review → Claude Code to generate and execute code → ChatGPT for post-PR review → Gemini for synthesis and knowledge capture. This “division-of-labor” chain connects think → build → review → codify in one loop.

TL;DR

Exploration → Gemini: diverge fast, surface patterns you overlooked.
Refinement → ChatGPT: turn insights into executable steps and check for logical gaps.
Integration → Claude Code: implement, polish, and ensure narrative/architecture coherence.
Example: for a product proposal, ask Gemini for deep needs → have ChatGPT list the functional spec → ask Claude Code to assemble a complete, shippable document or PR.

Summary of strengths: Gemini is fast with strong intuition; ChatGPT excels at reasoning; Claude is excellent at structure and clear expression. This also aligns with recent positioning: Google frames Gemini 2.5 as “thinking models” with fast/efficient Flash and stronger Pro; OpenAI highlights ChatGPT’s reasoning and planning for deep research; Anthropic pushes Claude Code as a hands-on terminal agent that can read repos, change code, and open PRs.

Why this split feels natural

Gemini: “intuition radar” Native multimodal and thinking-model design → fast and broad coverage. Great for opening up the problem and pulling on promising threads. With 2.5 you can dial thinking budget to go broad first, then deepen.
ChatGPT: structured planning and deep reasoning Strong at logical decomposition, argumentation, and integrating external sources — ideal for technical plans, tradeoff analysis, and review checklists.
Claude Code: gets things done Built as a terminal-first coding agent: read the repo, change code, run tasks, open PRs and trigger CI. Short path from plan to PR.

Note: model strengths shift over time. Treat this split as pragmatic defaults, not hard rules. Adjust per project type.

A day-to-day development loop (with a realistic example)

Let’s walk a loop using “add a subscription management module to an existing app”.

1) Discovery (Gemini)

Goal: surface true user pains behind “subscription management”, and produce journeys/boundary conditions.

Example prompt (to Gemini)

“We’re adding ‘subscription management’. From four angles — user segments (new/active/churn-risk), key motivations, cancel/retention touchpoints, and regulatory/payment compliance — map potential needs. Provide 3 high-leverage hypotheses we likely miss, each with a verifiable event and a quantifiable metric.”

Why Gemini: fast divergence/enumeration and adjustable “thinking budget” → go broad first, then narrow.

2) Planning (ChatGPT)

Goal: convert “hypothesis → metric → scenario” into system design and milestones.

Example prompt (to ChatGPT)

“Using the 3 high-leverage needs, output a technical solution sketch:

Backend data model and event tables (keys, indexes, hot/cold tiers);

Frontend key wireframes and the state machine;

Risk/compliance interception points;

A/B design and sample-size estimates; Conclude with milestones (two-week sprints) and a risk list (ranked by probability × impact).”

Why ChatGPT: great at structured planning and turning insights into a plan.

3) Code generation and execution (Claude Code)

Goal: write code, change code, run tasks, open a PR.

How to use:

Install @anthropic-ai/claude-code, enter your repo, and chat; Claude will index the repo and resolve dependencies.
In PRs/Issues, mention @claude to generate or modify code and create a PR.

Example command (conceptual)

# At repo root
claude "Create backend event tables for subscription management, add migrations, and integrate tests; if a Stripe Webhook exists, mount a handler. Then open a feature branch and submit a PR."

The value is end-to-end: read code, modify code, run scripts, and drive the Git flow in one loop.

4) Technical review (ChatGPT)

Goal: probe for issues and fix them. Give ChatGPT the Claude-generated PR and ask for a checklist across complexity, testability, rollback strategy, and failure paths, plus concrete Diff suggestions.

ChatGPT’s recent deep-research/long-chain reasoning is well-suited to serve as a contrarian reviewer.

5) Synthesis and knowledge capture (Gemini)

Goal: capture the iteration as postmortem cards and knowledge-base entries. Have Gemini read the PR, issues, CI logs, and alerts, then output:

A one-page postmortem (goals, actions, results, learnings, debt);
Three stakeholder summaries (ops/support/legal) with different lenses;
A next-iteration discovery list and a draft of automated regression cases.

Gemini shines on multi-role summaries and cross-scenario synthesis with speed and breadth.

Real-world tips

Document the split in the repo In CONTRIBUTING.md, codify the default loop: discover → plan → implement → review → synthesize. Reduce context-switching.
Wire actions into CI/CD Enable Claude Code GitHub Actions to trigger PR generation/modification from comments.
Mobile or Android projects Use Gemini Code Assist inside the IDE for error dissection and fix suggestions.
Mind safety and compliance Follow Google’s GenAI safety guidance: data minimization, explainability, and robust rollback.

Copyable loop checklist (paste into your team wiki)

Gemini — discovery: segments, journeys, edge cases, key metrics.
ChatGPT — planning: architecture/data/state machine, milestones, experiments.
Claude Code — implementation: read repo, change code, run tests, branch, PR.
ChatGPT — review: complexity, observability, rollback, failure paths.
Gemini — synthesis: one-pager, stakeholder summaries, next discovery + regression.

Closing

Treat models like people with roles, not a generic toolbox. Send the fast-intuitive one to explore, the deliberative one to plan, the hands-on one to ship. When each step has an “owner”, your delivery rhythm flows.

Would this split work for you? How would you tweak it? Drop thoughts in the comments.

Zed Adds ACP for Claude Code and Gemini: Many AI Teammates, One Editor

Aug 29, 2025

Vibe Sparking

Zed turns “agents” into a standard interface (ACP) and invites your command‑line agents into the editor. Gemini CLI is first‑class; Claude Code can run in Zed via a community ACP bridge. Multi‑agent coexistence is the new normal.

TL;DR

ACP is “LSP for AI coding agents.” Zed open‑sourced the spec (Apache). Any agent that implements ACP can run in Zed.
Gemini CLI integration: from Zed 0.201.5, create Gemini threads in the Agent panel; Zed can auto‑install; requires Gemini CLI ≥ 0.2.0.
Claude Code works via community bridge acp-claude-code: add one config snippet; supports auto‑accepting file edits permission mode.
Feature gaps to note: Gemini CLI currently lacks message history editing/restore, checkpoints, and SSH project usage — on the roadmap.
Data stays local: third‑party agent traffic does not tunnel through Zed servers. Multi‑buffer visual diffs and live previews are excellent.

Why This Matters

Editor–Agent decoupling Like LSP for languages, ACP lets you choose which agent plays. In the same project, switch agents for different tasks anytime.
Real CLI power, visualized in the editor Zed spawns real Gemini CLI subprocesses and speaks JSON‑RPC. You get all CLI capabilities plus live change visualization and multi‑buffer reviews.
Open spec and growing ecosystem ACP is open (Apache). The Neovim community is also adding ACP‑compatible agents. This isn’t single‑editor locked.

Setup and Quick Start (Gemini CLI)

Prepare Zed: Stable 0.201.5+ supports external agents. Open the Agent panel (cmd‑?), click the + button to start a Gemini thread. Optional keybinding:

[
  { "bindings": { "cmd-alt-g": ["agent::NewExternalAgentThread", { "agent": "gemini" }] } }
]

Prepare Gemini CLI:

If not installed, Zed will install it; otherwise it uses your PATH.
Requires ≥ 0.2.0. Upgrade:

npm install -g @google/gemini-cli@latest

Sign‑in options: Log in with Google / GEMINI_API_KEY / Vertex AI.

Usage tips:

Supports @file, @thread, @symbol, and web grabbing.
Not yet supported: message history edit/restore, checkpoints, SSH projects inside Zed.

One‑Step Claude Code in Zed (Community Bridge)

You can also use Claude Code in Zed via the community ACP bridge acp-claude-code. Add this to your Zed settings (auto‑accept edits supported):

{
  "agent_servers": {
    "claude-code": {
      "command": "npx",
      "args": ["acp-claude-code"],
      "env": {
        "ACP_PERMISSION_MODE": "acceptEdits"
      }
    }
  }
}

The bridge implements an ACP agent that wraps the Claude Code SDK: session continuity, streaming output, tool calls, permission modes, and more. The Zed team notes native support is in progress; use the bridge for now.

Note: acceptEdits only auto‑accepts file edits. bypassPermissions skips all prompts — not recommended unless running batch jobs in a clean sandbox.

Install Claude Code if needed:

npm install -g @anthropic-ai/claude-code

Recommended Scenarios

Large‑repo refactors and batch fixes: multi‑buffer review + live diffs = changes at a glance.
Multi‑agent “PK”: Gemini drafts refactor plans; Claude Code adds tests and commit messages — all inside one editor.
Security/compliance teams: external agent traffic doesn’t traverse Zed servers.

Debugging

Run dev: open acp logs from the command palette to inspect Zed↔Agent messages. Super clear for troubleshooting.
Need a quick thread shortcut? Action name: agent::NewExternalAgentThread.

Ecosystem Direction

Today: Gemini CLI integration shipped.
Happening now: Claude Code via community ACP bridge is active and improving.
Likely next: ACP is open; more agents (e.g., Codex CLI, Cursor CLI) can plug in. Zed’s post encourages third‑party agents and other editors to join.

Action Checklist (copy‑paste)

Gemini path

Update Zed to ≥ 0.201.5.
Open Agent panel → new Gemini thread. If needed: npm i -g @google/gemini-cli@latest.

Claude Code path (bridge)

Install Claude Code: npm i -g @anthropic-ai/claude-code.
Add the agent_servers snippet above; recommend ACP_PERMISSION_MODE=acceptEdits.

Debug

Use dev: open acp logs to diagnose permission/session issues.

Questions to Ponder

In your repo, which tasks suit Gemini better? Which ones suit Claude Code?
Should the team adopt a permission policy (e.g., auto‑accept edits only, never auto‑run commands)?
Worth hosting an internal “multi‑agent PK” learning session?

Plug Claude Code into China LLMs: DeepSeek / GLM-4.5 / Kimi K2

Aug 28, 2025

Vibe Sparking

Point Claude Code at Anthropic-compatible China model APIs and it just works: write code, run commands, even open PRs.

— Don’t overthink it. Follow this step-by-step and copy as you go.

Introduction

Everyone is trying Claude Code lately. The problem: your company network/budget doesn’t allow direct overseas access. Now what?

Good news: multiple top China providers offer Anthropic-compatible endpoints. Change Claude Code’s Base URL + Key and you’re in. This guide walks you through DeepSeek, Zhipu GLM-4.5, and Kimi K2, plus a quick “gotchas” checklist.

Quick Start (3 steps)

1) Install Claude Code

# Requires Node.js 18+
npm install -g @anthropic-ai/claude-code

After installation, run claude in your terminal for the interactive UI. Node 18+ is supported; use /config inside Claude Code to tweak settings.

2) Get an API key from a China provider

DeepSeek: create a key in the platform’s API Keys page.
Zhipu Z.AI (GLM-4.5): generate a key in the console.
Kimi K2 (Moonshot): generate a key in the console.

3) Set environment variables (temporary test)

Export these in your current terminal session. They will reset on new sessions. For persistent setup, see “Long-term config” below.

Option A: DeepSeek (official Anthropic-compatible endpoint)

Temporary setup:

export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_DeepSeek_API_Key"
export ANTHROPIC_MODEL="deepseek-chat"
export ANTHROPIC_SMALL_FAST_MODEL="deepseek-chat"
export API_TIMEOUT_MS=600000

Then in your project directory:

claude

DeepSeek’s docs provide the Anthropic-compatible path, recommended model names, and a note to raise the timeout for long outputs.

Long-term config (zsh example):

cat >> ~/.zshrc <<'EOF'
export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_DeepSeek_API_Key"
export ANTHROPIC_MODEL="deepseek-chat"
export ANTHROPIC_SMALL_FAST_MODEL="deepseek-chat"
export API_TIMEOUT_MS=600000
EOF

source ~/.zshrc

Verify: once started, type /status to see the current model; echo $ANTHROPIC_BASE_URL to double-check.

Option B: Zhipu GLM-4.5 (Z.AI official guides for Claude Code)

Temporary setup:

export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_ZAI_API_Key"
# Optional: set default model
export ANTHROPIC_MODEL="glm-4.5"

Z.AI’s docs publish the Anthropic-compatible endpoint and show how to switch glm-4.5 vs glm-4.5-air via ~/.claude/settings.json.

Switch model via settings.json (optional):

{
  "env": {
    "ANTHROPIC_MODEL": "glm-4.5-air"
  }
}

Open a new terminal and run claude, then /status in the UI.

Option C: Kimi K2 (Moonshot’s Anthropic compatibility)

Temporary setup (global domain is more reliable):

export ANTHROPIC_BASE_URL="https://api.moonshot.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_Moonshot_API_Key"
# Some deployments map temperature to ~0.6; defaults are fine

Moonshot emphasize compatibility with both OpenAI and Anthropic for K2 in the repo and blog. Community guides commonly use https://api.moonshot.ai/anthropic as the Base URL. Note: some posts show .cn which can fail. Prefer .ai or check the console docs.

Sanity Check: Did I really connect?

Inside claude, do these three quick checks:

Check model: /status or ask “What is your current model ID?”
Run a command: /bash echo "hello cc" to see if the permission prompt works.
Edit a file: ask it to create README_CC.md in a sample repo to confirm read/write.

These are all part of the recommended Claude Code workflow and setup.

Common Issues & Quick Fixes

Q1: 401 Unauthorized?

Claude Code supports two auth positions:

ANTHROPIC_API_KEY (sent as X-Api-Key)
ANTHROPIC_AUTH_TOKEN (sent as Authorization: Bearer)

China-compatible endpoints generally prefer ANTHROPIC_AUTH_TOKEN together with a custom Base URL.

Q2: Can’t connect / 404?

Ensure the Base URL includes /anthropic (e.g., DeepSeek and Moonshot compatibility endpoints).
Use .ai for Kimi; some .cn endpoints may not work.

Q3: Built-in WebSearch tool doesn’t respond?

When not using Anthropic’s official API, the built-in WebSearch tool is not available. Use an external MCP search tool (Tavily/Brave/DuckDuckGo, etc.).

Q4: Long outputs timing out?

DeepSeek recommends API_TIMEOUT_MS=600000 (10 minutes).

Q5: Multimodal / image messages?

Compatibility endpoints may not fully support every Anthropic field (e.g., images/doc content). Check the vendor docs.

Security & Compliance Notes

Protect repo secrets: add .env and secrets/** to permissions.deny in ~/.claude/settings.json.
Sanitize sensitive code: mirror the repo or remove keys before sharing with AI.
Permission mode: keep prompts enabled. Only use --dangerously-skip-permissions when you completely trust the environment.

Copy-Paste Cheat Sheet

Provider	Base URL	Required Env Var	Recommended Model
DeepSeek	`https://api.deepseek.com/anthropic`	`ANTHROPIC_AUTH_TOKEN`	`deepseek-chat`
Zhipu Z.AI	`https://api.z.ai/api/anthropic`	`ANTHROPIC_AUTH_TOKEN`	`glm-4.5` / `glm-4.5-air`
Kimi K2	`https://api.moonshot.ai/anthropic`	`ANTHROPIC_AUTH_TOKEN`	(use platform’s default routing)

All entries are from official vendor documentation or commonly used, tested settings.

Advanced: Persist Config in Claude Code

Don’t want to export every time? Put env vars in ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "xxxxx",
    "ANTHROPIC_MODEL": "deepseek-chat",
    "API_TIMEOUT_MS": "600000"
  }
}

settings.json is the officially recommended layered config (global/project), covering env, permissions, hooks, and more.

Conclusion

With domestic models connected, Claude Code remains the same “turn ideas into code” engine. Which one feels best? DeepSeek is fast, GLM-4.5 thinks steadily, and K2 is great value. Try them side by side.

Once you have one path working, your team can pilot low-cost AI code collaboration and turn efficiency into real outcomes.

Which combo works best for you? Any pitfalls you’ve hit? Share your practices in the comments.

Claude Code CLI Playbook: REPL, Pipes, Sessions & Permissions

Aug 28, 2025

Vibe Sparking

Introduction

GUIs are great, but the command line is faster, steadier, and composable. Claude Code CLI is that trusty knife: open a REPL, one-shot via pipes, resume past sessions, and fine-tune permissions — all with a single command.

This guide covers 90% of daily CLI usage with minimal memorization. If you can copy it, don’t type it. If you can automate it, don’t do it by hand.

TL;DR (5 quick lines)

REPL: claude to chat; claude "…" to start with a question.
Print/Pipe: -p is non-interactive one-shot; pair with --output-format json/stream-json for orchestration.
Sessions: -c resumes last; -r picks from history; --session-id pins a long-running thread.
Permissions: --permission-mode for granularity; --allowedTools/--disallowedTools for allow/deny lists.
Dangerous skip: --dangerously-skip-permissions only in offline/sandbox environments.

#1 REPL Mode: a “conversational IDE” in your terminal

Most common launches:

claude
claude "explain this project like I'm new here"

Handy tips:

claude --ide
claude --append-system-prompt "You are a careful code reviewer."

Mindset: REPL is perfect for exploratory work, incremental refactors, and step-by-step walkthroughs. Switch models on the fly with --model sonnet (or a full model ID).

#2 Print / Pipe Mode: scriptable, one-and-done

The core is -p: read from stdin → produce one response → exit. Ideal for scripts, CI, and batch jobs.

claude -p "explain this function"
cat server.log | claude -p "summarize error patterns"
git diff | claude -p "write a clear PR description"

Orchestration-friendly formats:

claude -p "summarize as JSON" --output-format json
cat api.md | claude -p --input-format stream-json --output-format stream-json

Pipeline example (with jq):

git diff | claude -p "summarize as JSON with keys: title, bullets" --output-format json \
  | jq -r '"# \(.title)\n- " + (.bullets | join("\n- "))'

#3 Session Management: resume, browse, and pin IDs

Four essentials:

claude -c
claude -c -p "Check for type errors"
claude -r
claude -r "550e8400-e29b-41d4-a716-446655440000" --no-interactive "fix all linting issues"

Pin a session ID for “long-term project concierge”:

export CC_SID="12345678-1234-1234-1234-123456789abc"
claude --session-id $CC_SID "Keep maintaining the release plan"

Tip: give each long-running task its own --session-id to keep context stable and history traceable.

#4 Permission Modes: speed with boundaries

Four modes, clearly defined:

claude --permission-mode default
claude --permission-mode acceptEdits
claude --permission-mode plan
claude --permission-mode bypassPermissions

“Permission prompt proxy” for non-interactive environments (e.g., CI): let an MCP tool handle prompts on your behalf.

claude -p --permission-prompt-tool mcp_auth_tool "run code review"

#5 Dangerous Skip: only in offline/sandbox

claude --dangerously-skip-permissions

Safe to use when:

Local sandbox with no network.
Demo/training setups with read-only FS or snapshots you can roll back.
Disposable environments you’ll destroy after the run.

Avoid when:

Production, repos with secrets, CI that writes to real resources.
Any scenario where you don’t want auto shell execution or file writes.

Rule of thumb: if you can avoid it, do. If you must, isolate first.

#6 Tool Lists: safer with allow/deny

Precisely control which tools can be used; child-command wildcards are supported.

claude --allowedTools "Bash(git:*), Edit"
claude --disallowedTools "Bash(rm:*)"

Recommended for CI: allow only what you need for edits; block dangerous commands.

claude -p \
  --permission-mode acceptEdits \
  --allowedTools "Edit" \
  --disallowedTools "Bash(rm:*), Bash(curl:*), Bash(wget:*)"

#7 I/O Formats: seamless upstream/downstream

claude -p "explain"
claude -p --input-format stream-json --output-format stream-json --replay-user-messages

What does --replay-user-messages do? In streamed JSON pipelines, it replays stdin “user” messages to stdout so middleware can align event flows upstream and downstream.

#8 Advanced Trio: model, dirs, and settings

claude --model sonnet --fallback-model opus -p "explain the migration plan"
claude --add-dir ../apps ../lib --cwd ./apps/web
claude --settings ./cc.settings.json

Example cc.settings.json:

{
  "verbose": true,
  "maxTurns": 8,
  "appendSystemPrompt": "Prefer clear diffs and small PRs."
}

Cheat Sheet (copy-friendly)

claude
claude "help write a release note"
claude -p "explain this function" --output-format text
cat logs.txt | claude -p "find top 5 recurring errors"
git diff | claude -p "summarize as JSON" --output-format json
claude -c
claude -r "550e8400-e29b-41d4-a716-446655440000" --no-interactive "finish the refactor"
claude --session-id 12345678-1234-1234-1234-123456789abc
claude --permission-mode plan
claude --allowedTools "Edit"
claude --disallowedTools "Bash(rm:*)"
claude --dangerously-skip-permissions

Wrap-up

The CLI shines for two reasons: speed and composability. Use REPL for exploration; use -p for automation and pipelines. With traceable sessions, controllable permissions, and orchestratable output formats, Claude Code fits naturally into your engineering rhythm.

Type 10× fewer commands, deliver 10× more results.

Which combo works best for you? Share your “command flows” in the comments — I’ll turn a few into posters and send you a Vibe Coding quick-start pack.

Discussion

Do you use REPL or -p more often — and why?
When do you enable acceptEdits?
Do you have a one-liner pipeline you swear by? Share it so we can learn from it.

Mastering Claude Code Sessions: Continue, Resume, Automate

Aug 28, 2025

Vibe Sparking

Teach Claude Code to “pick up the thread” with the quartet of --continue / --resume / --session-id / non-interactive mode, so you can keep previous context intact, coordinate multiple tasks, and automate reliably.

Introduction

Writing code is like training — the worst enemy is interruption. You discussed a refactor plan with Claude Code yesterday, and today you forget where you left off? Running multiple threads gets mixed up? Your script loses context after two turns?

This article explains how Claude Code sessions work and how to resume instantly, recover specific threads, run many in parallel, and keep context in scripts — so your Vibe Coding rhythm never drops.

Four Real Scenarios Where Sessions Help

Continue yesterday’s thread: jump right back into the last conversation.
Work on two tracks: bugfix on one branch, new feature on another, without interference.
Script automation: multi-turn interaction in CI/scripts without losing context.
Privacy and cost: local retention and awareness of summarization cost.

The Session Management Quartet

1) Fastest: continue the most recent conversation (`--continue` / `-c`)

Command:
Terminal window
```
claude --continue
# or
claude -c
```
Mindset: zero choices — immediately resume the most recent session; no need to reconfigure the environment.
Tip: resume the latest session inside a script and print the result:
Terminal window
```
claude --continue --print "Continue the refactor and add unit tests"
```
(--print is equivalent to -p, i.e., non-interactive output.)

2) More precise: resume a specific session (`--resume` / `-r`)

Interactive “session picker”:
Terminal window
```
claude --resume
```
This shows a list of past sessions (start time, first prompt or summary, message count). Use arrow keys to choose. Great when you switch tracks several times a day.

Resume directly by session ID:

claude --resume 550e8400-e29b-41d4-a716-446655440000 "Finish the API abstraction layer"
# or
claude -r 550e8400-e29b-41d4-a716-446655440000 "Keep writing integration tests"

Perfect for scripts/automation where you need exact control.

3) Script-friendly: capture `session_id` + non-interactive multi-turn

Idea: start once to capture a session_id, then chain every subsequent step with --resume $sid.

# Step 1: start a session and grab session_id (present in JSON output)
sid=$(claude -p "Start a refactor session: list the risk points" --output-format json | jq -r '.session_id')

# Step 2: chain non-interactive turns
claude -p --resume "$sid" "According to the plan, refactor utils/date.ts first"
claude -p --resume "$sid" "Add ts-jest config and unit test examples"

Key point: --output-format json includes a session_id field; you can also use --no-interactive with --resume for strictly non-interactive runs.

Caution: some users report that repeatedly using --continue in non-interactive mode may create a new session, which looks like it resumed but actually changed IDs. For automation, prefer fixed session_id + --resume.

4) In REPL too: the `/resume` command

Inside the interactive REPL, type:

/resume

You’ll get a list of sessions to restore. This is the same source as --resume/--continue, triggering the same SessionStart/Resume logic (as noted in Hooks docs).

Handy REPL keys:

Esc Esc: edit the previous message
↑ / ↓: browse history in the current session

Great for quickly tweaking your last prompt.

Parallel, Not Cross-Talk: isolate sessions with Git worktrees

Want to push “bugfix” and “new feature” at the same time? Use git worktree to create two working directories. Launch Claude Code separately in each directory so context stays naturally isolated:

git worktree add ../proj-feature-a -b feature-a
git worktree add ../proj-bugfix bugfix-123

cd ../proj-feature-a && claude
cd ../proj-bugfix   && claude

This workflow is strongly recommended: sessions and file state won’t affect each other.

Privacy & Cost: session retention and background summaries

Local retention: the client stores sessions locally (configurable; common defaults keep ~30 days) for --resume. Enterprises can set zero data retention.
Background summarization: to power --resume lists and previews, Claude Code performs background session summarization, incurring a small token cost.

Copy-and-Run “Session Toolbox”

Bash multi-turn template:

# Start a session and save its ID
sid=$(claude -p "Prepare release: generate change list" --output-format json | jq -r '.session_id')

# Chain subsequent steps to the same session
claude -p --resume "$sid" "Generate release notes in Chinese and English"
claude -p --resume "$sid" "Check CI failures and provide fix commands"
claude -p --resume "$sid" "Output a final checklist.md"

(--print/-p is non-interactive; you can also force non-interactive with --no-interactive.)

Quick interactive entry points:

# Most recent
claude --continue

# Pick from history
claude --resume

# In REPL
/resume

Advanced: hook sessions into team workflows (optional)

If you’ve configured Hooks such as SessionStart/SessionEnd, resuming a session also triggers them. You can automatically load the latest issues, change summaries, or safety checks at resume time.

Wrap-up

Session management isn’t a nice-to-have — it’s the foundation for keeping momentum. Use --continue for quick, ad-hoc resumption; use --resume + session_id for long-running, replayable work; use worktree for physical isolation; and bring it all into scripts. Your Vibe Coding will evolve from sketchy inspiration to a reproducible creative pipeline.

Which session pattern do you need most right now? Share in the comments.

Claude Code Playbook 1.10: Outsource Permissions to Your MCP Tool with claude code --permission-prompt-tool

Aug 28, 2025

Vibe Sparking

Introduction

Keep getting interrupted by permission prompts? Want Claude Code to run in CI/CD, nightly jobs, or remote containers without flipping “allow everything”?

The answer is this switch: --permission-prompt-tool. It delegates the decision of “allow this tool call?” to a specific MCP tool you choose. It supports conditional approval, audit trails, and can run in non-interactive CLI and headless setups. The CLI docs explicitly state its purpose: in non-interactive mode, your MCP tool handles permission prompts.

Permission order is also clear: first check settings.json / --allowedTools / --disallowedTools. If a rule applies, it’s allowed or denied immediately. Otherwise Claude calls your --permission-prompt-tool. The official SDK docs describe the full flow and the JSON response format.

TL;DR

What it is: a bridge that delegates “allow or deny tool use” to an MCP tool. Great for automation, headless, and compliance.
How decisions are made: static rules first (settings/allowed/disallowed). If no match, Claude calls your permission agent, which returns JSON: allow or deny.
Best use cases: CI/CD, batch refactors, remote containers/servers, IDE/plugins, enterprise audit/compliance.
Why sec teams like it: auditable, recordable, granular, aligned with IAM and least privilege. Even better with an MCP allowlist.

What it actually does

It forwards the question “should we allow this tool call?” to your MCP tool. That MCP tool can enforce approvals, allow/deny lists, time-of-day policies, Slack approvals, risk scoring—your rules, your control. This works in both CLI and headless modes.

Claude Code applies a three-layer permission check:

Layer 1: Static configuration

Check predefined permission rules first:

settings.json
CLI --allowedTools
CLI --disallowedTools

Layer 2: Decision

If layer 1 yields a clear answer → allow or deny directly. If there’s no rule → go to layer 3.

Layer 3: Dynamic prompt

Ask the MCP tool you specify to decide: --permission-prompt-tool your_custom_tool

Running examples

Suppose Claude wants to use Write to modify files.

Case 1: statically allowed

{
  "allowedTools": ["Write", "Read"]
}

Result: allowed immediately; MCP tool is not called.

Case 2: statically denied

{
  "disallowedTools": ["Write"]
}

Result: denied immediately; MCP tool is not called.

Case 3: no static rule

{
  "allowedTools": ["Read"]
  // no rule about Write
}

Result: call the MCP tool specified by --permission-prompt-tool.

Expressed in code:

def check_permission(tool_name):
    # Layer 1: static config
    if tool_name in settings.allowedTools:
        return True  # allow immediately

    if tool_name in settings.disallowedTools:
        return False  # deny immediately

    # Layer 2: no rule, ask MCP tool
    if permission_prompt_tool:
        return permission_prompt_tool.ask_permission(tool_name)

    # Default (usually: ask the user)
    return prompt_user(tool_name)

Practical workflows

Enterprise example: most tools pre-configured; exceptional calls require dynamic approval.

claude code --allowedTools "Read,Grep,LS" \
            --disallowedTools "Bash:rm,Bash:sudo" \
            --permission-prompt-tool enterprise_approver \
            "analyze codebase"

Flow:

1. Claude uses Read → allowed by static config ✅
1. Claude wants Bash:rm → denied by static config ❌
1. Claude wants Write → no rule; ask enterprise_approver ❓

Benefits:

Performance: fast decisions for common tools via static rules
Flexibility: edge cases handled dynamically
Security: default to deny; explicit authorization required

4 high-impact use cases

1) CI/CD and headless scripts

Goal: run code edits, test fixes, and reporting in pipelines without permission pop-ups.
How:

claude -p "fix flaky tests and commit" \
  --allowedTools "Read,Grep" \
  --disallowedTools "Bash(rm*),Write" \
  --mcp-config ci-tools.json \
  --permission-prompt-tool mcp__sec__approval_prompt \
  --output-format json

Effect: anything not covered by static rules gets routed to mcp__sec__approval_prompt for remote approval. Pipelines keep flowing.

2) Large-scale batch refactors

Goal: nightly bulk edits, formatting, and migration PRs.
How: mark “critical-path edits” as require-approval, allow the rest statically. Log every change for audit.
Basis: define granular IAM rules by tool/path, e.g., Edit(docs/**), Bash(npm run test:*).

3) Remote containers & dev servers

Goal: safely allow necessary actions where there’s no UI (Docker/SSH, headless).
How: enable the permission prompt tool in headless (non-interactive) mode:

claude -p "build and publish image" \
  --permission-prompt-tool mcp__guard__prompt \
  --mcp-config /etc/mcp/servers.json

Note: headless docs indicate --permission-prompt-tool applies in --print non-interactive flows.

4) “Delegated approver” inside IDE/plugins

Goal: let a GUI agent or Slack bot handle approvals on behalf of the IDE user.
How: MCP tool shows a GUI or posts a Slack card; approver clicks and returns allow/deny.
Security: MCP servers must be trusted and auditable per org policy.

How it works (official mechanism translated)

Priority: check settings.json and CLI --allowedTools / --disallowedTools first. If they decide, act; otherwise call your MCP tool.
Response format (must be a JSON string):
- Allow:
```
{"behavior":"allow","updatedInput":{...}}
```
- Deny:
```
{"behavior":"deny","message":"..."}
```
- updatedInput lets your agent return human-amended input back to the model (e.g., an edited diff).

Minimal viable MCP tool

TypeScript (conceptual)

const server = new McpServer({ name:"sec-approval", version:"0.0.1" });

server.tool(
  "approval_prompt",
  "Return allow/deny for tool use",
  { tool_name: z.string(), input: z.object({}).passthrough() },
  async ({ tool_name, input }) => {
    const allow = await riskCheck(tool_name, input); // your risk logic
    const payload = allow
      ? { behavior: "allow", updatedInput: input }
      : { behavior: "deny", message: "Policy denied by SEC team" };
    return { content: [{ type: "text", text: JSON.stringify(payload) }] };
  }
);

Start it like this:

claude -p "migrate configs safely" \
  --allowedTools "Read,Grep" \
  --disallowedTools "Bash(rm*),Write" \
  --mcp-config security-tools.json \
  --permission-prompt-tool mcp__sec-approval__approval_prompt

Headless and CLI parameter mappings are available in the official docs.

Python (conceptual)

async def approval_prompt(tool_name: str, input: dict):
    ok = policy_match(tool_name, input)
    if ok:
        return json.dumps({"behavior":"allow","updatedInput":input})
    return json.dumps({"behavior":"deny","message":f"Denied {tool_name}"})

The official SDK also documents Python/TS structures and fields.

Compared to “skip permissions”

--dangerously-skip-permissions: bluntly skips all prompts. The docs warn to use sparingly.
--permission-prompt-tool: controlled, auditable, and extensible. Aligns with enterprise security/compliance. You can authorize by directory/command, e.g., Bash(npm run test:*), Edit(docs/**).

Best-practice checklist (enterprise-ready)

Three layers: static first (settings/allowed/disallowed) → MCP agent as fallback → default deny.
MCP allowlist: connect only to trusted MCP servers, managed via repo config.
Granular matching: use Bash(…), Edit(…), mcp__server, mcp__server__tool for precise authorization; wildcards are not supported by MCP.
Audit and replay: log decisions in the permission agent; pair with --output-format json to persist runs.
Risk isolation: run inside containers/DevContainers to limit blast radius.

Common pitfalls

Wrong tool naming: mcp__<server>__<tool> denotes a single tool; mcp__<server> allows all tools from that server. No wildcards.
Expecting prompts in interactive mode: this switch primarily targets --print non-interactive flows.
Treating it as a silver bullet: keep base permissions in settings/allowed/disallowed to reduce calls and network exposure.
Ignoring MCP security: evaluate third-party servers carefully and apply least privilege.

Quick copy-paste

Allow common read-only tools + deny risky commands + MCP fallback:

claude -p "refactor and open PR" \
  --allowedTools "Read,Grep,LS" \
  --disallowedTools "Bash(rm*),Write" \
  --mcp-config team-mcp.json \
  --permission-prompt-tool mcp__approver__prompt \
  --output-format json

Authorize by command granularity:

claude -p "run tests" \
  --allowedTools "Bash(npm run test:*),Read" \
  --permission-prompt-tool mcp__approver__prompt

All parameter semantics, permission modes, and match patterns are covered in the official CLI / IAM / headless docs.

Conclusion

--permission-prompt-tool is not just a toggle—it’s an enterprise-grade “permission gateway” interface. You can move risk evaluation, human approvals, and audit trails into a single MCP tool. Automation without recklessness: keep both efficiency and security strong.

Does this permission design satisfy your compliance needs? Tell us how you’d wire Slack/Teams/ticketing to “click-to-approve”.

Who Should Use Claude Code? Perspectives by Role — Vibe Coding Experiences and Use‑Case Analysis

Aug 27, 2025

Vibe Sparking

In recent years, AI coding assistants have proliferated. Among them, Anthropic’s Claude Code (CC) has drawn attention by positioning itself as an “intelligent coding tool in your terminal.”

“Vibe Coding” refers to using these tools to rapidly turn ideas in your head into code — a fast‑iterating, intuition‑driven development flow.

This article distills feedback from different types of users, explains the reasons behind the patterns, and summarizes where Claude Code shines in Vibe Coding. We also compare CC to adjacent tools (Cursor, GitHub Copilot, OpenAI Codex CLI, Cursor CLI, Google Gemini CLI, etc.) to highlight strengths, weaknesses, and fit.

How Different People Experience Claude Code

Users with different backgrounds report notably different experiences when using CC for Vibe Coding:

1) Zero‑code beginners: a steep climb

Claude Code isn’t a one‑click “build an app” magic wand. It expects clear natural‑language tasking so it can “plan, write code, and ensure it works.”
People with no coding literacy struggle to phrase effective instructions or judge correctness, so CC is “hard to drive.”
CC primarily runs in the terminal, assuming some dev environment and command‑line experience — a non‑trivial barrier for beginners.

2) Senior architects: cautiously skeptical

Many view CC’s value as “limited” — hand‑writing the code feels safer and more reliable.
CC can help “debug and fix issues,” scanning a codebase for bugs and proposing patches, but results still require human review.
The permissioned workflow asks for user approvals step by step (you can enable Yolo mode to auto‑approve), which can feel inefficient.
CC remains early and can be unstable.
Net: treat it as an assistant, not a crutch.

3) Technical PMs / founders / CEOs: newfound leverage

PMs, founders, and CEOs call it “finally a way to quickly ship ideas stuck in my head.”
Many ideas you might hesitate to “ask the team to build” can be prototyped solo with CC, such as:
- Personalized feed apps
- Note‑taking utilities
- Small Apple Watch data parsers
- Personal sites
In enterprises, CTOs experiment with LLM add‑ons for legacy systems — smart support, recommendations, and more.
Intercom’s example: Claude Code “lets us build things we never had time for — from AI data‑labeling tools to an ROI calculator for sales.”

Using Claude Code for Internal System Integration

⚡ Rapidly integrating heterogeneous systems

CC excels at automating drudgery: fixing lint, resolving merge conflicts, drafting release notes.
It can quickly scaffold glue code across APIs, databases, and filesystems, enabling fast experiments.

🤖 Injecting LLM intelligence into legacy systems

CC can generate integration layers for LLM capabilities and wrap natural‑language skills into existing systems.
Examples: internal knowledge‑base chatbots; CRM smart‑recommendation modules.
CC can “stay aware of the whole project structure,” and via MCP pull data from Google Drive, Figma, Slack, etc.

👉 Positioning: an accelerator, not a replacement. You still need monitoring, tests, and mature architectures.

Adoption Challenges

1) Reliability

LLMs are probabilistic; outputs won’t be correct every time.
For tasks like global renaming, “let the IDE’s refactor tools do it” is often safer.
Community feedback: CC performs better on web/front‑end than on Swift/iOS.
Bottom line: great as an assistant; not a fully automated path to production‑grade software.

2) Cost

Individual subscriptions are manageable; organization‑wide costs add up.
Reported averages: roughly ~$6 per person per day; with Sonnet 4, team costs can run $100–$200 per person per month.
Pricing: Pro ~ $17/month; Max up to $200/month.
Conclusion: fine for personal dev; building products/services purely via API usage can get expensive.

Where Claude Code Fits for Vibe Coding

Creative prototypes and personal projects: quickly assemble small apps, algorithm prototypes, or validation scripts.
- Hundreds of lines of code in minutes.
Understanding and refactoring complex codebases: analyze logic, sketch architecture maps, propose global improvements.
Everyday acceleration and automation: generate tests/docs, fix formatting, go from issue to patch PR.

👉 Best practice: Human + AI collaboration. Humans steer; AI accelerates.

Comparisons with Other AI Coding Tools

Tool	Traits	Best‑fit scenarios	Limits
Claude Code	Terminal agent; strong reasoning	Deep debugging; large codebases; creative prototyping	Cost; imperfect reliability
GitHub Copilot	IDE plugin; code completion	Everyday small‑step coding	Weak at global planning; not great for 0→1
Cursor (Editor)	VS Code‑like, AI‑enhanced	IDE‑centric workflows; front‑end	Agent mode feels heavy; middling stability
Cursor CLI	CLI, multi‑model	Flexible; supports Anthropic/OpenAI/Google	Beta; stability varies
OpenAI Codex CLI	Terminal AI agent; multimodal	Debugging; automation; open and flexible	Still evolving; code quality varies
Google Gemini CLI	Free/open; long context	Big projects; low budgets; broad tasks	Ecosystem younger; shallower reasoning depth

Takeaways and Recommendations

Best‑suited users:
- Technically literate PMs / founders / CEOs: turn ideas into reality fast.
- Dev teams: internal integrations and LLM experiments.
Less suited:
- Complete beginners (barrier too high).
- Senior architects who need rigor and determinism (use CC as an aide, not a driver).

Claude Code isn’t a silver bullet, but in the Vibe Coding arena it helps more ideas leap from mind to reality. The winner of this AI developer‑productivity race will be whoever best balances cost with reliability.

Stop Arguing — Ship with Claude Code: Turn Newcomers and Engineers into One Team

Aug 27, 2025

Vibe Sparking

Claude Code pushes the long‑running trend of “write less code, get more done” to the extreme. Writing code is only a slice of engineering. Dialogue and collaboration help both “non‑coders” and engineers convert Unknown Unknowns into Known Unknowns — that’s how Claude Code becomes real productivity.

Introduction: Why the arguments?

A discussion has been making the rounds: some say LLMs let “non‑coders” ship small software; professional engineers counter that software engineering is much more than code — requirements, architecture, integration, and long‑term maintenance. Both sides are right — just speaking from different vantage points. Behind the debate is a decades‑long industry arc of “writing less code,” and Claude Code is simply the next turn of the crank.

1) This shift isn’t sudden

Software has steadily reduced mechanical work:

Rails scaffolding: one command generates MVC; prototypes get moving fast.
Protocol Buffers: efficient cross‑language RPC without bespoke serialization code.
Scala implicits/given: use the type system to remove boilerplate and glue.

LLMs extend that same trajectory: write less code, accomplish more. But the “engineering” never goes away.

2) What exactly does Claude Code change?

It lives in your terminal — not just another chat box.
It takes action: edits files, runs commands, creates commits.
It integrates with external systems via MCP (read design docs, update Jira, use custom tools).

Automation also moves into CI/CD: GitHub Actions can @claude in PRs/Issues to auto‑review, branch, and propose fixes.

On the ground, enterprise rollout is happening — teams can assign standard or advanced Claude/Claude Code seats with central management and tracking.

3) Why do “non‑coders” feel empowered?

Because this time AI offers them a usable interface:

PMs can spin up prototypes in natural language and surface ambiguities earlier.
Ops/design can tweak small features or scripts directly without waiting in backlogs.

Media are observing the same trend. “Vibe Coding” — programming closer to intent, less fixation on code — is heating up. Reporters have done pair‑coding sessions and, in two days, shipped small UI and feature changes. The term took off in early 2025.

4) What worries engineers?

Durability and control:

Architectural boundaries, data contracts, performance budgets, observability — none of these are solved by “a couple snippets.”
Tests and acceptance criteria must be explicit. Tools like Cucumber/Gherkin let you write business‑readable, executable acceptance tests that AI can also help generate and maintain.

In short: AI can help us write less code, but the engineering organization and constraints must be stronger.

5) Two common misconceptions

Equating programming with “the act of typing code.”
Assuming a small app stitched together with AI represents how the industry builds software — therefore, the industry will be replaced.

These crop up among junior developers too. Experience teaches that the core of software engineering is the “engineering.”

6) Stop arguing: adopt a collaboration playbook

Goal: turn Unknown Unknowns into Known Unknowns. Use this minimal loop — a team can adopt it today.

1) Define boundaries in a shared language

Write five Gherkin acceptances (Feature/Scenario). PMs/business own the prose; engineers ensure testability.
Let Claude Code read the .feature files and draft a minimal implementation plus test skeletons.

2) Start with Claude Code — don’t end there

Have it generate prototypes and PRs, but keep merge authority with a responsible owner.
Add “gate rules” for critical modules: merges require passing baseline tests and performance budgets.

3) Push automation into CI

In GitHub Actions, trigger @claude suggestions/fixes on new Issues, failed CI, or specific labels.
Have it produce risk notes and rollback templates to reduce merge anxiety.

4) Keep data and docs in lockstep

Via MCP, allow Claude to read design docs and ADRs (architecture decision records).
PRs must update ADRs and interface contracts (Proto/JSON Schema). Keep the trio “code–contract–tests” consistent.

5) Review continuously

Weekly human+AI code review to curate an “AI blind‑spots list.”
Track failure and rollback rates separately for “AI‑authored changes” and use data to set scope and limits.

Conclusion: Conversation > argument

Bringing “non‑coders” into the loop is good — they sit close to the business and push 0→1. Having engineers own boundaries and constraints is necessary — that’s how systems run long and run stable. Arguments won’t close the loop; collaboration will.

Next step: take a 3–5 day feature in your product and run it through the collaboration playbook above. After a retro, decide how far to open the gates for Claude Code.

Suggested illustrations (2:1, no Chinese text)

Cover: a PM and an engineer high‑five in front of a terminal; the screen shows CLI, PRs, Gherkin scenario cards, and an AI helper icon; warm tech illustration with ample whitespace.
Key sections:
- “History of writing less code”: icons for Rails scaffolding, Proto contracts, Scala given/implicit on a timeline.
- “Claude Code capabilities”: terminal UI + file tree + Git commit arrows + connectors to Jira/Drive.
- “Collaboration playbook”: five cards (Acceptance → Prototype → CI → Contracts → Retro) arranged like a kanban.

Discussion prompts

How much permission should Claude Code have in your team, and why?
Any real cases where AI caused issues? How did you harden the process afterward?

Multi‑language title options (3 sets)

- Simplified Chinese: 别吵了，用 Claude Code 开工吧：把“门外汉”与工程师变成一支队
- English: Stop Arguing — Ship with Claude Code: Turn “Newcomers” and Engineers into One Team
- Traditional Chinese: 別吵了，用 Claude Code 開工吧：把「門外漢」與工程師變成一支隊
- Japanese: 議論はもうやめて、Claude Codeで出荷しよう。素人とエンジニアを“一つのチーム”に
- French: Assez de débats — Livrez avec Claude Code : unissez « non‑codeurs » et ingénieurs
- Spanish: Basta de discutir: entrega con Claude Code y une a « no técnicos » e ingenieros
- Portuguese: Chega de briga: entregue com Claude Code e una « não técnicos » e engenheiros
- slug: stop-arguing-ship-with-claude-code
- Simplified Chinese: 写得少，做得多：Claude Code 如何把争论变成协作
- English: Write Less, Ship More: How Claude Code Turns Debate into Collaboration
- Traditional Chinese: 寫得少，做得多：Claude Code 如何把爭論變成協作
- Japanese: 書く量を減らして成果を増やす：Claude Codeが“論争→協業”に変える方法
- French: Écrire moins, livrer plus : Claude Code transforme les débats en collaborations
- Spanish: Escribe menos, entrega más: Claude Code convierte el debate en colaboración
- Portuguese: Escreva menos, entregue mais: Claude Code transforma debate em colaboração
- slug: write-less-ship-more-claude-code
- Simplified Chinese: Vibe Coding 落地指南：把 Unknown Unknowns 变成 Known Unknowns
- English: Vibe Coding Playbook: Turn Unknown Unknowns into Known Unknowns
- Traditional Chinese: Vibe Coding 落地指南：把 Unknown Unknowns 變成 Known Unknowns
- Japanese: Vibe Coding実践：Unknown UnknownsをKnown Unknownsへ
- French: Guide Vibe Coding : transformer les inconnues inconnues en inconnues connues
- Spanish: Guía de Vibe Coding: de incógnitas desconocidas a incógnitas conocidas
- Portuguese: Guia de Vibe Coding: do desconhecido‑desconhecido ao conhecido‑desconhecido
- slug: vibe-coding-playbook-unknowns

This nails the real friction: AI doesn’t replace engineering — it amplifies collaboration. Saving this and running a small feature with @claude + Gherkin.
Just enabled @claude + Gherkin in our repo — speed unlocked. From now on: write acceptance first, then code.
Non‑coders × engineers is the winning combo. Next time the “replacement” debate comes up, I’ll share this piece.

References

X thread on “engineering vs. code” and how to turn conflict into collaboration.
Claude Code capabilities and MCP extensions.
GitHub Actions integration and official actions.
Enterprise seat rollouts and team adoption reports.
The rise of Vibe Coding in the field (Notion example, podcast).
Cucumber/Gherkin for executable acceptance in natural language.
The lineage of “writing less code”: Rails scaffolding, Protobuf, Scala implicits.
WIRED: Why did a $10B startup let me vibe‑code for them — and why did I love it?
https://www.wired.com/story/why-did-a-10-billion-dollar-startup-let-me-vibe-code-for-them-and-why-did-i-love-it
WIRED: Uncanny Valley podcast — How to become a vibe coder
https://www.wired.com/story/uncanny-valley-podcast-how-to-become-a-vibe-coder
TechRadar: Anthropic is adding Claude Code to business plans
https://www.techradar.com/pro/anthropic-is-adding-claude-code-to-business-plans-so-now-all-your-workers-can-enjoy-a-major-ai-boost

Use Claude Code + GitHub Actions to Make @claude Your Automated Teammate

Aug 27, 2025

Vibe Sparking

Mention @claude right inside PRs, Issues, and scheduled jobs. It follows your repo’s CLAUDE.md to review code, fix bugs, implement small features, and even post daily reports — all on GitHub‑hosted runners with zero server ops.

Introduction

Ever felt this? PRs pile up and reviews lag; Issues are clearly described, yet no one wants to take the first swing.

With Claude Code’s GitHub Actions, a single @claude hands off those repetitive but necessary tasks. It reads context, adheres to your project conventions, and can create or update PRs — even propose implementations.

Highlights (why it’s worth it)

@claude on demand: mention it in PR/Issue comments to trigger either “interactive replies” or “auto‑execute” — v1 auto‑detects which to use.
Aligns to your team norms: put a CLAUDE.md at the repo root with code style, review rules, and common patterns; Claude follows it during execution.
Multi‑cloud options: use Anthropic API directly or route via AWS Bedrock / Google Vertex AI to match enterprise compliance and billing.
Extensible SDK: the official Claude Code SDK supports Headless/TS/Python so you can embed a “code‑writing agent” into various workflows.
No infra to manage: defaults to GitHub‑hosted runners; private repos consume Action minutes, public repos are free.

Install and Upgrade (fast track)

A. Quick install (recommended)

Open the Claude app in your terminal and run: /install-github-app.
Follow prompts to install the GitHub App and configure the ANTHROPIC_API_KEY secret.
Test by mentioning @claude in a repo comment.

If that path doesn’t work, use manual install: install the official GitHub App → add ANTHROPIC_API_KEY to the repo → copy examples/claude.yml to .github/workflows/.

B. Upgrade from Beta to v1 (breaking changes)

Action version: @beta → @v1
Remove the mode: config (v1 auto‑detects)
direct_prompt renamed to prompt
CLI flags move under claude_args (e.g., --max-turns, --model, --system-prompt)

Minimal workflows (copy as needed)

1) Comment‑mention code review with @claude

name: Claude Code (mentions)
on:
  issue_comment: { types: [created] }
  pull_request_review_comment: { types: [created] }
jobs:
  run:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          # leave prompt empty to auto-respond to @claude

Behavior: when someone comments @claude this code may have a concurrency issue; suggest and fix, the Action reads context, replies, and, if appropriate, commits changes.

2) Slash command for automated review

name: Code Review
on:
  pull_request: { types: [opened, synchronize] }
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: "/review"
          claude_args: "--max-turns 5"

Explanation: on new or updated PRs, trigger a light /review, limiting turns to contain token usage.

3) Daily report at 9:00

name: Daily Report
on:
  schedule: [{ cron: "0 9 * * *" }]
jobs:
  report:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: "Summarize yesterday's commits and open issues"
          claude_args: "--model claude-sonnet-4-20250514"

Explanation: scans recent commits and open issues, posts a daily summary to a comment or new issue.

Recommended use cases (real time‑savers)

Security reviews and compliance checklists: add a minimum‑bar privacy/security review to PRs.
Bug reproduction and small fixes: describe an error in a comment and have @claude reproduce, locate, and submit a narrow fix.
Unit‑test completion: auto‑add missing tests for critical modules, guided by your CLAUDE.md style.
Multi‑repo refactors: with SDK/headless mode, batch “unify scaffolds, upgrade deps, replace legacy functions.”
Enterprise cloud compliance: if you need data residency or specific billing, switch to Bedrock/Vertex paths to unify identity and audit.

Write a solid CLAUDE.md (so AI understands your project)

Place CLAUDE.md at the repo root with:

Code style and directory conventions
Commit message format (e.g., Conventional Commits)
Preferred implementation patterns and anti‑patterns for components/services
Review checklist: security, performance, testability, observability
Reference links (allow @file references to key docs/examples)

Tip: keep CLAUDE.md short and sharp. Clarity drives stable outputs. Offload length to linked docs or @file attachments.

Cost and security (what leaders care about)

Cost control:

Public repos use hosted runners for free; private repos consume minutes and storage.
Set --max-turns to cap dialog length; add timeouts and concurrency limits.
Schedule jobs off peak; reduce unnecessary triggers; manage artifact retention.

Security:

Keep API keys in Secrets and reference with ${{ secrets.ANTHROPIC_API_KEY }} — never hardcode.
Least privilege: grant your GitHub App only the permissions it needs; audit CI trigger events.

Advanced (power‑user tips)

Custom GitHub App: for brand/permissions control, create a tenant‑specific App and authenticate via create-github-app-token.
Faster runners: for large repos or heavier tasks, consider self‑hosted or accelerated runners to reduce job time and cost.
SDK pipelines: use the Claude Code SDK to orchestrate “read repo → generate patch → verify → open PR” as your engineered agent.

Conclusion

The busier your team, the more you benefit from a reliable “automated teammate.” Put conventions in CLAUDE.md and workflows in GitHub Actions, and hand the tedious yet critical chores to Claude — freeing people to create higher‑value work.

Which workflow will you hand to @claude first? Share your ideas or pass this guide to a teammate and try it today.

Title options and slugs (multi‑language)

Plug @claude into GitHub Actions: Your Automated Teammate Is Live
- slug: claude-code-github-actions-automated-teammate
One Comment, One Delivery: Claude Code × GitHub Actions in Practice
- slug: one-comment-one-delivery-claude-code-github-actions
Offload Reviews, Fixes, and Reports to AI: A GitHub Actions Guide
- slug: ai-reviews-fixes-reports-github-actions-guide

Illustration prompts (2:1, no Chinese text)

Cover: a developer types “@claude” in a GitHub PR while an AI assistant materializes task cards like “Review”, “Fix tests”, and “Create PR”; clean pastels, minimal UI, soft shadows, 2:1.
Section art:
1. Flow: GitHub comment → Claude analysis → PR update; flat modern arrows and cards, 2:1.
2. A CLAUDE.md style guide pinned with checkmarks for security, tests, performance; 2:1.
3. Bedrock & Vertex AI icons connecting to GitHub Actions runners; compliance shield; 2:1.

Claude Code with GitHub Copilot Sonnet Model

Aug 27, 2025

Vibe Sparking

Scenario: Claude Code runs out of quota right when you need it, but you happen to have a GitHub Copilot subscription. By using an open-source Copilot API proxy that exposes Copilot as an OpenAI/Anthropic compatible API, you can plug Claude Code into it and keep Vibe Coding. This guide walks you through setup and recommends safer, more compliant usage.

What It Is and What It Does

This is a reverse‑engineered GitHub Copilot API proxy that turns Copilot into an OpenAI-compatible /v1/chat/completions service and an Anthropic-compatible /v1/messages service. The upside: any tool supporting those APIs can use it—including Claude Code. The project ships with usage dashboards, rate limiting, manual approval, and support for Business/Enterprise accounts.

Note: This is not officially supported by GitHub. GitHub explicitly restricts excessive automation/bulk requests, which may trigger risk controls or temporary suspension. Use at your own risk and stay reasonable.

Why It’s Worth a Try

Three practical benefits:

Low interruption: when Claude Code runs dry, continue writing, editing, and testing through Copilot.
Low friction: use OpenAI/Anthropic compatible endpoints so Claude Code switches without major changes.
Controllable and auditable: includes usage boards, rate limiting/wait mechanisms, and manual approvals to avoid tripping risk controls.

Quick Start: Just 3 Commands

Prerequisite: you have an active GitHub Copilot subscription.

# 1) Interactive login
npx copilot-api@latest auth

# 2) Start the proxy and generate a Claude Code connect command
npx copilot-api@latest start --claude-code

# 3) Paste the suggested command in a new terminal (or set env vars manually)
ANTHROPIC_API_KEY=sk-dummy \
ANTHROPIC_BASE_URL=http://localhost:4141 \
claude --dangerously-skip-permissions

The above flow comes from the built‑in --claude-code wizard. You can also persist the environment via .claude/settings.json to avoid exporting variables every time.

More robust approach: avoid using --dangerously-skip-permissions long‑term. Prefer Claude Code’s permissions and environment settings—configure ANTHROPIC_BASE_URL, default model, and a permissions allowlist in the project’s .claude/settings.json to prevent mistakes.

Docker vs npx

npx one‑liner: npx copilot-api@latest start (optionally add --port 8080 --verbose)
Docker with persistent login: mount ./copilot-data to persist tokens so container restarts don’t lose auth.
Terminal window
```
mkdir -p ./copilot-data
docker run -p 4141:4141 \
  -v $(pwd)/copilot-data:/root/.local/share/copilot-api \
  copilot-api
```
You can pass GH_TOKEN during build/run, which works nicely in CI/CD.

Recommended “Safe & Compliant” Posture

Bind to localhost only: listen on 127.0.0.1:4141; don’t expose publicly. Use a tunnel/VPN if needed.
Enable rate limits: --rate-limit 30 --wait and, when appropriate, --manual for manual review to lower anomaly rates.
Declare account type: specify personal / Business / Enterprise via --account-type.
Respect the policies: read GitHub’s Acceptable Use Policies and Copilot Terms; avoid excessive automation/bulk requests.
Principle of least privilege: use Claude Code’s permissions.deny to block .env, secrets/**, and other sensitive paths.

Common Pitfalls and Troubleshooting

Token/model limits: check issues related to max_prompt_tokens, oversized context, and suggested fixes.
Headless login: use auth to obtain a token, then pass it via --github-token.
Risk controls triggered: first pause automated/batch tasks, increase latency, enable --manual, then review policy compliance.

Who It’s For—and Not For

Good fit: individual developers and small teams with a paid Copilot plan who want a smooth backup when Claude Code quota runs low.
Not ideal: strict enterprise compliance environments—prefer official Claude Code integrations (e.g., Bedrock/Vertex/LLM gateways/enterprise proxies).

[Illustration suggestion | 2:1] Theme: left side “indie desk setup”, right side “enterprise server room” with a compliance shield and cloud provider badges. English prompt: Split-screen illustration: indie desk setup vs enterprise server room with a compliance shield. Minimal, 2:1.

One‑Page Reference Checklist

Local quick run:

npx copilot-api@latest auth
npx copilot-api@latest start --rate-limit 30 --wait --claude-code
# In a new terminal, run the Claude Code start command as prompted

Project‑level environment via .claude/settings.json at repo root:

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:4141"
  },
  "permissions": {
    "deny": ["Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)"]
  }
}

(See official settings docs for more options.)

Wrap‑Up

Think of it as an emergency power pack. When timing matters, it keeps your Vibe Coding flow alive; day‑to‑day, it can serve as a low‑cost online backup. But remember—stable, compliant, least privilege is the productivity that lets you sleep well.

Will you make it your long‑term safety net, or keep it for emergencies only? What do you think?

Voice-Driven Vibe Coding on Mac with Spokenly + Claude Code

Aug 26, 2025

Vibe Sparking

You speak, it writes, things run. Hands off the keyboard, code still flies.

Introduction

Over the past two months I’ve become addicted to Vibe Coding. Pair Spokenly for voice input with Claude Code as a “capable terminal copilot”. I keep three panes open: Plan, Build, Review. I grab tea; when I’m back it’s just “acceptance” and “next steps”. Before bed I toss in a big task; next morning I check results like a ruthless boss — day’s rhythm, locked.

This guide shows the complete setup for driving Claude Code by voice on macOS with Spokenly. Install and go — you can ship tonight.

TL;DR

Spokenly: global hotkey, dictation in any input field; supports local Whisper, offline-ready; or bring your own cloud API key; Agent Mode to control your Mac by voice.
Claude Code: smart pair programmer in your terminal. After npm i -g @anthropic-ai/claude-code, just run claude; supports slash commands like /model /config /ide /compact, deep IDE integration with VS Code/JetBrains.
Voice tips: use Option+Enter or /terminal-setup for multi-line input; Esc Esc to edit the last message; run three-pane flow for Plan → Execute → Review.

1) Tools and Installation

1) Spokenly (speech → text)

Website: https://spokenly.app/ — supports on-device Apple Speech Recognition, Whisper, 100+ languages, Local-only privacy mode, Agent Mode, searchable history; Mac + iPhone.
App Store: free download, Pro adds cloud models; recent releases add Soniox, Parakeet v3, re-transcription on history, and more.

2) Claude Code (terminal AI)

# Node.js 18+
npm i -g @anthropic-ai/claude-code

cd your-project

claude

You’ll be up in 30 seconds. Supports MCP tools, running commands, editing files, creating commits, and IDE connections.

3) IDE (optional but highly recommended)

VS Code/Cursor/Windsurf: when launched in the integrated terminal, claude auto-installs the extension.
JetBrains: install the plugin and restart; from an external terminal use /ide to connect to the IDE.

Alternative: Apple’s built-in Dictation works too, but Spokenly wins on features and privacy (especially multilingual and offline Whisper).

2) Voice control in 5 minutes

Step 1: Configure Spokenly

Grant microphone permission on first launch.
Set a global Push-to-Talk hotkey (e.g., Right Command) in Preferences.
Choose Local-only to use Apple Speech Recognition — fully offline and private.
Enable Auto language to freely mix Chinese and English.
Mode: “Type at cursor” so dictated text flows into your terminal/editor like you’re typing.

Step 2: Start Claude Code

Run claude in your project directory.
Need multi-line input or long requirements?
- Use Option+Enter for multi-line; or run /terminal-setup to bind Shift+Enter to newline.
In IDEs: start claude in an external terminal, then /ide to connect to VS Code/JetBrains to enable selection context, IDE Diffs, and more.

Step 3: Start talking

Focus the Claude input box → hold PTT hotkey to speak → release to send.
Need to tweak the last line? Press Esc Esc to edit and resend.

3) The three-pane Vibe Coding flow: Plan | Build | Review

Pane A: Architect (Plan)

Say: “Add OAuth login to a Next.js project. First provide a task list and file-change plan, each step within 20 lines.”
Commands: use /model to pick the model; /compact to compress context and keep focus.

Pane B: Builder (Implement)

Say: “Follow pane A’s plan. Write code and self-test; if errors occur, fix automatically; run scripts when needed.”
For structure, dictate with Option+Enter: “Block 1 is the API route; Block 2 is the UI component…”

Pane C: Reviewer (Review)

Commands: /review, /cost for token/cost; if needed, use /config to constrain tools and scope.
In IDE mode, review diffs directly in the editor for a near-native pair-programming feel.

Pro tip: use separate project directories per task to start claude. Each session history is isolated per directory for clean context switching.

4) Bedtime “overnight sprint” voice template

Break big tasks into four spoken parts so Claude Code stays on track:

Goal: one-sentence objective + success criteria
Scope: which directories to touch and which to avoid (allow/deny lists)
Checks: self-test scripts, lint, unit/E2E tests
Deliverables: PR summary, diff, changelog

Example: “Tonight migrate the Settlement module from REST to tRPC. Only modify /server/ and /app/billing/. Run pnpm test and pnpm lint — both must pass. Output steps and risks, and provide a rollback guide.”

5) Seven tips for smoother dictation

Speak structure: “Heading: … New paragraph. List: one, two, three.” Helps produce cleaner docs.
State constraints: “Change at most three areas, each under 30 lines.” Prevents overreach.
Set boundaries: “Only allow Bash: pnpm*, git*.” (combine with /config to limit tools)
Require checks: “After changes, run npm run test; if it fails, roll back.”
Mix languages: APIs and identifiers in English are recognized more accurately; Spokenly auto-detects.
Multi-line input: Option+Enter or /terminal-setup.
Edit last message: Esc Esc to revise.

6) Privacy and cost

Local-first: Spokenly’s Local-only mode keeps audio on-device; pair with offline Whisper.
Bring your own key: if you need cloud transcription, plug in OpenAI/Deepgram/Groq, etc., to control cost; Pro subscription simplifies setup.
Claude costs: use /cost to check usage; control model and thinking depth via /model.

7) Common pitfalls and fixes

Terminal newline quirks → use Option+Enter or /terminal-setup to bind Shift+Enter.
IDE extension not installed → run claude in the IDE’s integrated terminal; restart JetBrains; or from an external terminal use /ide to connect.
Dictation not landing in terminal → ensure focus on Claude input; adjust Spokenly hotkey conflicts.
Want Apple Dictation → System Settings → Keyboard → enable Dictation, set “Press Control key twice”.

Ready-to-read dictation prompts

“Add an export-CSV endpoint under /api/orders. First provide a plan, then write code, then run tests, showing each step.”
“Move state management on the payment page from Redux to Zustand. Only touch existing logic, keep UI. List 3 risk points.”
“Read the six modules under /server/report/, generate a dependency graph, and output a visualization script (choose d2 or mermaid).”

Conclusion

Voice-driving Claude Code isn’t a gimmick — it helps you reach the “clarify → deliver” state faster. The clearer you describe requirements, the steadier Claude executes — and the better the Vibe. Try the three-pane method tonight and let it handle your pre-sleep ticket.

Where does this workflow save you the most time? Share your take.

Anthropic (Claude Code’s parent) Nears $10B Funding: An Analysis

Aug 25, 2025

Vibe Sparking

As reported by Bloomberg on August 22, 2025, leading AI startup Anthropic is reportedly close to securing a massive funding round of up to $10 billion — far above prior expectations and among the largest single financing rounds in the AI sector to date.

Based on a comprehensive review of the “Anthropic nearing a $10 billion raise” reports, this analysis applies multi‑source fact‑checking, data validation, and critical reasoning to assess the story’s truthfulness and reliability. We cross‑checked at least 15 sources and found several discrepancies and points of concern. Below, we examine factual verification, data analysis, logical consistency, incentives, market psychology, and potential risks.

Fact‑Check Results

Funding Size and Timeline Verification

Cross‑referencing Bloomberg, CNBC, TechCrunch, Reuters, and other outlets confirms that Anthropic is indeed negotiating a new funding round, but key details vary. Early reporting (e.g., Bloomberg) cited a $3–5 billion raise at a roughly $170 billion valuation, not the $10 billion some outlets repeated.

A more realistic timeline looks like this:

2025‑07‑29: Bloomberg first reported Anthropic’s talks for a $3–5B round at a ~$170B valuation, led by Iconiq Capital, with a potential second lead. The company was also said to be engaging the Qatar Investment Authority (QIA) and Singapore’s GIC for participation.
2025‑08‑20/21: Several outlets, including Bloomberg, updated that the target could rise to “as much as $10B,” potentially becoming one of the largest AI startup financings ever. Anonymous sources cited strong investor demand pushing the target from $5B to $10B.
Investor roster: Iconiq Capital as lead appears consistent across reports, but other names vary. Some mention TPG, Lightspeed, Spark Capital, Menlo Ventures, and continued outreach to QIA and GIC. These discrepancies suggest no single official confirmation yet.

Conclusion: A new Anthropic raise is real, but the size and full investor lineup remain fluid. The “doubling” from $5B to $10B hinges on anonymous sourcing and lacks formal confirmation.

Valuation Trajectory Analysis

Anthropic’s recent valuation path raises plausibility questions:

2025‑03: Closed a $3.5B round led by Lightspeed at a post‑money of ~$61.5B.
2025‑07: Rumored valuation for the new round rose to ~$170B — a 176% jump in four months.

Annualized, that implies >500% growth, a pace that typically requires extraordinary fundamentals.

Revenue Data: Validation and Caveats

Annualized revenue run‑rate (ARR)

Multiple sources indicate explosive ARR growth over the past year:

Late 2024: ~$1.0B
2025‑05: ~$3.0B
2025‑07: ~$4–5B

Key caveat: ARR often extrapolates “a hot month × 12,” which can materially overstate actual full‑year revenue during hypergrowth.

Customer concentration risk

Anthropic appears to have material concentration in a few customers:

Top two customers contribute roughly ~$1.4B ARR (~28%).
Largest single customer is the AI coding assistant Cursor at around ~$0.5B.
The Claude Code product contributes nearly ~$0.4B ARR.

Loss of one or more of these anchors would significantly impact revenue.

Logic Gaps and Common‑Sense Checks

Is the raise size reasonable?

Cash burn: Raising $3.5B in March and then targeting $5–10B just five months later implies very heavy spend — potentially hundreds of millions to billions per month.
Revenue multiple: Anthropic’s valuation/revenue multiple of ~34× vs OpenAI’s ~25× suggests a premium that’s hard to justify without clear differentiation.

Timing coincidences

Disclosures surfaced nearly in parallel with OpenAI financing chatter, suggesting signaling.
Heavy reliance on “people familiar with the matter,” with limited on‑record confirmation.
Media “trial balloons” can manufacture urgency and scarcity to lift headline valuations.

Investor Profiles and Geopolitics

Iconiq Capital

Strengths: >$80B AUM with ultra‑high‑net‑worth Silicon Valley clientele (e.g., Zuckerberg, Hoffman).
Questions:
- Client‑driven preferences can influence allocation style.
- Historically favors later‑stage steadier bets; a ~$1B single check would be unusually large.

Sovereign funds and geopolitics

QIA and GIC involvement introduces geopolitical and national‑security review complexity.
Management has previously voiced concerns about optics and regulatory scrutiny tied to Middle East capital, though capital intensity may force pragmatism.

People, Incentives, and Needs

Anthropic: Needs substantial capital to compete with OpenAI; lofty valuations help with talent, partnerships, and a potential IPO arc.
Investors: FOMO is acute; sovereigns emphasize strategic positioning.
Media: “Record‑breaking round” headlines drive traffic; anonymous sourcing lowers the bar, mixing motives.

Market Psychology and Bubble Signals

Valuations decoupling from fundamentals relative to traditional tech.
Capital concentration: ~64% of US VC dollars in H1 2025 flowed to AI.
Herding behavior: Fear of missing the next ChatGPT inflates risks.

Risks and Red Flags

Technology and commercialization

Moat durability: Performance gaps between Claude and GPT‑5 appear to be narrowing.
Business model pressure: API pricing wars and sustained compute costs weigh on margins.

Policy and regulation

US export controls and the EU AI Act may constrain expansion.
Sovereign participation could trigger CFIUS review, adding uncertainty.

Conclusion and Recommendations

Fact‑check conclusions

Directionally true: Anthropic is raising capital.
Headline number uncertain: $10B is unconfirmed; $5B looks more likely.
Valuation froth: Fundamentals may not support the premium.
Incomplete information: Signs of selective disclosure.

Investor takeaways

Stay rational about big round headlines.
Prioritize actual revenue and profitability over valuation theater.
Beware bubble dynamics and momentum herding.
Wait for official confirmation before anchoring decisions.

In today’s AI investment cycle, media narratives, corporate signaling, and on‑the‑ground reality often diverge. In moments of mania, noise overwhelms signal. Only disciplined verification and clear‑eyed analysis can keep decisions grounded in truth instead of sentiment.

Create a Gemini Subagent in Claude Code (1M Context)

Aug 25, 2025

Vibe Sparking

Spin up a “sub‑agent” inside Claude Code dedicated to calling the Gemini CLI. Offload heavy code scans, architecture overviews, and security audits to Gemini’s 1M‑token context; keep Claude as the brain to interpret results and land changes. Cheaper, simpler, and faster.

Introduction

For repository‑wide overviews, cross‑repo search, and architecture mapping, even Claude can get bottlenecked by context size. The fix is simple: outsource large‑mouth analysis to the Gemini CLI. We’ll create a Gemini analysis subagent in Claude Code that only does three things: build commands → call the CLI → hand raw results back. Claude stays unpolluted and focused on decisions and edits — a powerful pairing.

Why now? Google open‑sourced the Gemini CLI. Personal accounts can connect to Gemini 2.5 Pro for free, with a 1M‑token context and generous preview quota. For whole‑repo analysis, it’s basically a “power‑up.”

Figure suggestion (2:1 illustration): An engineer orchestrates two robots at a console: left “Claude (planner/editor)”, right “Gemini subagent” ingesting a massive code pile. Use English UI labels only.

How the Combo Works

Roles: Brain + Subagent

Claude (primary agent): converses, breaks down tasks, reviews, and lands changes (edit files, run tests, etc.).
Gemini subagent: does not analyze itself; it only turns requests into Gemini CLI commands, executes them, and returns raw output.
Context isolation: the subagent runs with its own context and doesn’t pollute the main chat; excellent for repeated reuse.

Setup (5 minutes)

Install Gemini CLI (pick one)

# Run via npx (no install)
npx https://github.com/google-gemini/gemini-cli

# Global install (npm)
npm install -g @google/gemini-cli

# Or Homebrew (macOS/Linux)
brew install gemini-cli

Requires Node.js ≥ 20. Supports OAuth login, API Key, or Vertex AI.

Log in / authenticate

# Recommended: OAuth (personal Google account; preview quota is generous)
gemini   # follow browser login flow

# Or: use an AI Studio API key
export GEMINI_API_KEY="YOUR_API_KEY"
gemini

Official posts confirm 1M context and high preview limits; the GitHub README covers OAuth / API key / Vertex options.

Verify it works

gemini -p "Say hello and print current directory files briefly"

Create the “Gemini Analyzer” Subagent in Claude Code

Claude Code lets you define subagents as Markdown with YAML frontmatter. At the project level, place them under .claude/agents/ (user‑level: ~/.claude/agents/).

Create: .claude/agents/gemini-analyzer.md

---
name: gemini-analyzer
description: Manages Gemini CLI for large codebase analysis and pattern detection. Use proactively when Claude needs to analyze extensive code patterns, architectural overviews, or search through large codebases efficiently.
tools: Bash, Read, Write
---


You are a Gemini CLI manager specialized in delegating complex codebase analysis tasks to the Gemini CLI tool.


Your sole responsibility is to:

1. Receive analysis requests from Claude

2. Format appropriate Gemini CLI commands

3. Execute the Gemini CLI with proper parameters

4. Return the results back to Claude

5. NEVER perform the actual analysis yourself - only manage the Gemini CLI


When invoked:

1. Understand the analysis request (patterns to find, architectural questions, etc.)

2. Determine the appropriate Gemini CLI flags and parameters:

   - Use `--all-files` for comprehensive codebase analysis

   - Use specific prompts that focus on the requested analysis

   - Consider using `--yolo` mode for non-destructive analysis tasks

3. Execute the Gemini CLI command with the constructed prompt

4. Return the raw output from Gemini CLI to Claude without modification

5. Do NOT attempt to interpret, analyze, or act on the results


Example workflow:

- Request: "Find all authentication patterns in the codebase"

- Action: `gemini --all-files -p "Analyze this codebase and identify all authentication patterns, including login flows, token handling, and access control mechanisms. Focus on the implementation details and architectural patterns used."`

- Output: Return Gemini's analysis directly to Claude


Key principles:

- You are a CLI wrapper, not an analyst

- Always use the most appropriate Gemini CLI flags for the task

- Return complete, unfiltered results

- Let Claude handle interpretation and follow-up actions

- Focus on efficient command construction and execution


## Detailed Examples by Use Case


### 1. Pattern Detection

**Request**: "Find all React hooks usage patterns"

**Command**: `gemini --all-files -p "Analyze this codebase and identify all React hooks usage patterns. Show how useState, useEffect, useContext, and custom hooks are being used. Include examples of best practices and potential issues."`


**Request**: "Locate all database query patterns"

**Command**: `gemini --all-files -p "Find all database query patterns in this codebase. Include SQL queries, ORM usage, connection handling, and any database-related utilities. Show the different approaches used."`


### 2. Architecture Analysis

**Request**: "Provide an architectural overview of the application"

**Command**: `gemini --all-files -p "Analyze the overall architecture of this application. Identify the main components, data flow, directory structure, key patterns, and how different parts of the system interact. Focus on high-level organization and design decisions."`


**Request**: "Analyze the component hierarchy and structure"

**Command**: `gemini --all-files -p "Examine the React component hierarchy and structure. Identify reusable components, layout patterns, prop drilling, state management approaches, and component composition patterns used throughout the application."`


### 3. Code Quality Analysis

**Request**: "Find potential performance bottlenecks"

**Command**: `gemini --all-files -p "Analyze this codebase for potential performance bottlenecks. Look for expensive operations, inefficient data structures, unnecessary re-renders, large bundle sizes, and optimization opportunities."`


**Request**: "Identify security vulnerabilities"

**Command**: `gemini --all-files -p "Scan this codebase for potential security vulnerabilities. Look for authentication issues, input validation problems, XSS vulnerabilities, unsafe data handling, and security best practices violations."`


### 4. Technology Stack Analysis

**Request**: "Identify all third-party dependencies and their usage"

**Command**: `gemini --all-files -p "Analyze all third-party dependencies and libraries used in this project. Show how each major dependency is utilized, identify any potential redundancies, outdated packages, or security concerns."`


**Request**: "Map out the testing strategy and coverage"

**Command**: `gemini --all-files -p "Examine the testing strategy used in this codebase. Identify test frameworks, testing patterns, test coverage areas, mocking strategies, and areas that might need more testing."`


### 5. Feature Analysis

**Request**: "Trace a specific feature implementation"

**Command**: `gemini --all-files -p "Trace the implementation of [specific feature] throughout the codebase. Show all files involved, data flow, API endpoints, UI components, and how the feature integrates with the rest of the system."`


**Request**: "Find all API endpoints and their usage"

**Command**: `gemini --all-files -p "Catalog all API endpoints in this application. Include REST routes, GraphQL resolvers, tRPC procedures, their request/response patterns, authentication requirements, and how they're consumed by the frontend."`


### 6. Migration and Refactoring Analysis

**Request**: "Identify legacy code patterns that need modernization"

**Command**: `gemini --all-files -p "Identify outdated or legacy code patterns that could be modernized. Look for old React patterns, deprecated APIs, inefficient implementations, and opportunities to use newer language features."`


**Request**: "Analyze consistency across similar components"

**Command**: `gemini --all-files -p "Examine similar components or modules for consistency. Identify variations in patterns, naming conventions, implementation approaches, and opportunities for standardization or creating reusable abstractions."`


### 7. Documentation and Knowledge Transfer

**Request**: "Generate onboarding documentation insights"

**Command**: `gemini --all-files -p "Analyze this codebase to help create onboarding documentation. Identify key concepts developers need to understand, important files and directories, setup requirements, and the most critical patterns to learn first."`


### Command Flag Guidelines:

- Always use `--all-files` for comprehensive analysis

- Add `--yolo` for non-destructive analysis tasks to skip confirmations

- Use `-p` for single prompts or `-i` for interactive sessions

- Consider `--debug` if you need to troubleshoot Gemini CLI issues

Subagent file format, placement, and available tools (Bash/Read/Write) follow the official docs.

Tip: You can also create/edit subagents interactively via /agents.

Permissions and Safety: “Green‑light” the Subagent

To let the subagent run gemini smoothly, whitelist the relevant Bash calls in .claude/settings.json, and strictly blacklist sensitive reads:

{
  "permissions": {
    "allow": [
      "Bash(gemini*)",
      "Read(**/*.md)",
      "Read(src/**)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(curl:*)"
    ]
  }
}

The permission system and examples follow Claude Code’s official Settings docs.

Three Ready‑to‑Run Scenarios

Usage: talk to the primary agent in Claude Code, e.g., “Have the gemini-analyzer subagent scan the whole repo’s authentication implementation and return the raw output.”

1) Pattern search: authn/authz implementations

Claude instruction

Use the gemini-analyzer subagent to analyze authentication patterns across the repo and return raw output.

Subagent command (example)

gemini -p "Analyze this codebase and list all authentication & authorization patterns: login flows, token/session handling, middleware/guards, RBAC/ABAC, and any security pitfalls. Show file paths and code excerpts when helpful."

-p runs a non‑interactive, one‑shot analysis. Run at the repo root so Gemini reads the project context; optionally add --include-directories for extras.

2) Architecture bird’s‑eye: components and data flow

Claude instruction

Use gemini-analyzer to provide a high‑level architectural overview and return the raw result.

Subagent command

gemini -p "Give an architectural overview: main modules, data flow, directory structure, cross-cutting concerns, and how backend APIs connect to frontend components. Output a concise map with file references."

Large context is ideal for whole‑repo maps and cross‑layer traces — perfect for the Gemini CLI’s 1M tokens.

3) Security sweep: XSS/injection/secrets

Claude instruction

Ask gemini-analyzer to scan for potential security issues and return raw findings.

Subagent command

gemini -p "Scan for potential security issues: XSS, SQL/NoSQL injection, hard-coded secrets, weak crypto, unsafe deserialization, missing input validation, authz gaps. Provide evidence snippets and file paths."

The subagent returns raw output only; Claude interprets it and prepares fix PRs.

Best Practices to Max Out Efficiency

One‑liner role hint: put “Use proactively” in description so Claude will automatically delegate big jobs.
Cost/speed toggle: during exploration, try -m gemini-2.5-flash; once direction is right, switch to -m gemini-2.5-pro for a deep pass.
Fixed templates: keep common prompt snippets like “dependency map” and “test coverage report” for stable reuse.
Clean context: subagent and main chat are separated, preventing huge scans from bloating the main thread.
Least privilege: only allow necessary Bash/Read rules; deny sensitive files decisively.
Don’t panic on errors: if commands fail, retry with --debug and return logs verbatim for Claude to triage.

Conclusion

This Claude brain + Gemini subagent combo is ideal for whole‑repo sweeps, architecture health checks, migration assessments, and dependency cleanup. You stay in Claude Code and hand heavy lifting to Gemini. You save money and time. The next time you need “wide view + grounded action,” run them together.

Where would you use this? Share your scenarios — I can help further refine the subagent prompts for your case.

Do Vibe Coding Right with Claude Code: A FAANG Engineer’s Practical Pipeline

Aug 24, 2025

Vibe Sparking

Introduction

This year, Silicon Valley gave a name to a style of coding: Vibe Coding. It’s not slacking off, and it’s not “let the AI do everything.” It’s using Claude Code as a “disciplined junior engineer” so teams ship faster and more reliably.

What is Claude Code?

An agentic coding assistant in your terminal: it plans, reads/writes your project, runs commands, and uses slash commands to codify your workflow.

FAANG‑Style “Vibe Coding” Best Practices (copy straight into your team)

Goal: Treat Claude as an orchestratable junior engineer. Humans own architecture and decisions; AI executes and reports progress.

1) Design and reviews first

Write a design doc covering architecture, boundaries, integration points.
Do a senior‑engineer review to front‑load the pain. This prevents the AI from “speeding you off course” later. (Pattern lifted from FAANG workflows.)

2) Use plan‑mode for a one‑time plan

For each feature, enter plan‑mode once, generate a task list, then execute against that list. Stability improves dramatically. Community experience shows this “rigid sequence” shifts Claude from “occasionally off the rails” to “reliably intern‑like.”

3) TDD: have Claude write tests first

Give Claude your business rules → generate unit/integration tests → human review → then let it implement code.
Multiple write‑ups emphasize: tests first slashes hallucinations and regressions.

4) Codify your workflow with slash commands

Turn frequent actions into reusable commands:

/spec to generate a feature spec
/tests <feature> to produce TDD tests
/implement <feature> to commit a PR strictly by the task list
/context to inspect context usage and tool calls Official support includes custom commands and namespaces, so you can bake the team process into the repo.

5) Context hygiene

Do one thing at a time; constrain directories and files; pipe logs/CSVs to Claude when needed; let it fetch data or read links when appropriate.

6) Review and safety gates

Two‑person review plus staging verification, as used in FAANG.
Run /security-review in the terminal for an ad‑hoc security scan before you submit.

7) Quantify improvements

Track lead time from proposal → production and your regression rate. Many report ~30% faster, but measure against your own baseline.

Our minimal rollout pack (copy into your repo)

Create .claude/commands/ in the repo root:

You are a Staff Engineer. Convert the user story into a crisp spec:
- Problem, Scope, Non-goals
- Architecture sketch & interfaces
- Risks & open questions
Return Markdown only.

You are a TDD coach. For <feature>, generate unit & integration tests first.
- Cover edge cases, error handling, contracts
- Use the project’s test framework
- Do NOT implement code yet

Follow the approved plan. Implement <feature> with tiny commits.
- Reference related tests
- Explain changes in the PR body
- Ask before migrating schemas

Combine with /context to watch tokens and tool usage; split work when needed.

Common pitfalls

Treating Claude as a black box, dumping a huge blob of requirements in one go.
Skipping tests and reviews, shipping on “it runs on my machine.” Quality drifts, and orgs fall into the “AI speed trap.”
Running plan‑mode in parallel for multiple features → context drift and rework.

Why this approach works

The direction is clear: developers are rapidly embracing AI, and automation in coding/testing is rising. Teams who wield AI well will compound their advantage.
To win on quality, you must bake engineering process into Claude’s commands and plans — not “chat casually and let it write.”

Conclusion

Vibe Coding isn’t laziness. It’s “human judgment + Claude execution” assembled into a measurable, auditable, reusable pipeline. Starting today, give your team: design first → one‑time plan‑mode → tests first → slash‑command codification → security + review to close. Fast and steady.

What’s missing from this pipeline for your team? Share your experience in the comments.

ccpm Enables Claude Code: PRD → Epic → GitHub Issues → Production Code

Aug 24, 2025

Vibe Sparking

ccpm (Claude Code PM) connects PRD → Epic → GitHub Issues → Production Code in a closed loop, paired with Git worktree and parallel sub-agents to ensure you don’t lose context, don’t block tasks, don’t bury landmines.

Introduction

In AI coding, two things are most feared: context evaporation and parallel chaos. The result is rework, conflicts, and invisible progress.

ccpm’s approach is very “engineering-oriented”: use GitHub Issues as the single source of truth, where every line of code can be traced back to specifications. Claude only handles execution, while state, dependencies, and auditing all reside in Issues, allowing the entire team to seamlessly hand off work.

Core Philosophy: No Vibe Coding - all code must be traceable to clear specifications.

Why ccpm?

Specification-Driven: Structurally decompose PRDs into Epic/Tasks, then sync to GitHub Issues. Full traceability across the chain.
Parallel Execution: One Issue isn’t one person, but multiple parallel workflows (DB, API, UI, testing…) progressing concurrently in isolated worktrees.
Context Preservation: Main thread only orchestrates; each agent works in its own small context without mutual contamination.
GitHub Native Collaboration: Issue = project status; comments = audit trail; multiple humans/AI agents can hand off in real-time without “what did AI do” meetings.

Bonus: ccpm recommends installing the gh-sub-issue extension to manage parent-child tasks; without the extension, it automatically falls back to task lists and still works.

Visual Workflow (60-Second Onboarding)

PRD → Epic → Task → GitHub Sync → Parallel Execution Typical command flow (in Claude Code):

/pm:prd-new memory-system
/pm:prd-parse memory-system
/pm:epic-oneshot memory-system
/pm:issue-start 1235

Each step produces artifacts: .claude/prds/*.md, epics/*/epic.md, task markdown files, and corresponding GitHub Issues.

Highlight Checklist (Your Top 6 Concerns)

Issues as “Database”: Status is Issue status; comments are naturally audit trails. Transparent with zero learning curve.
Multi-Agent Parallelism: Same Issue can spawn multiple concurrent workflows, significantly boosting throughput.
Worktree Isolation: Each parallel track gets its own branch/directory, drastically reducing conflicts and context pollution.
Commands as Process: From /pm:prd-new to /pm:issue-sync, crystallize PM habits into executable commands.
Fast Local, Stable Cloud: Files locally first, then explicit sync to GitHub, balancing speed with control.
Parent-Child Task Management: Supports GitHub Sub-issues (extension or native API), clear hierarchy with explicit dependencies.

Installation & Initialization (2 Minutes)

Recommend cloning ccpm to your project root directory, or copying the .claude directory into existing projects. Run initialization on first use.

Step 1 | Copy Template

cd /path/to/your-project
git clone https://github.com/automazeio/ccpm.git .

If you already have CLAUDE.md, you can use /re-init later to merge necessary rules.

Step 2 | Initialize in Claude Code

/pm:init

This will: install/verify GitHub CLI, login, install gh-sub-issue extension, create necessary directories, update .gitignore, generate CLAUDE.md.

Step 3 | Warm Up Context

/context:create

Now you can start new features:

/pm:prd-new your-feature

PRD → Epic → Tasks → Issues complete artifact pipeline with one command.

gh-sub-issue installation command (optional but highly recommended):

gh extension install yahsan2/gh-sub-issue

Supports creating/linking/listing/removing sub-tasks.

Quick Command Reference

PRD: /pm:prd-new, /pm:prd-parse, /pm:prd-list, /pm:prd-status
Epic: /pm:epic-decompose, /pm:epic-oneshot, /pm:epic-sync, /pm:epic-show
Issue: /pm:issue-start, /pm:issue-sync, /pm:issue-status, /pm:issue-close
Workbench: /pm:next, /pm:status, /pm:standup, /pm:blocked All built into ccpm’s command set, type /pm:help for summary.

Recommended Use Cases

0-to-1 MVP: Ungrounded PRDs are the worst. ccpm uses commands to anchor “ideas” to Issues and code.
Multi-person Parallel Iteration: Split same Epic into multiple pipelines, UI/API/DB/testing progressing simultaneously, reducing serial waits.
Legacy Project Refactoring: Write risk points into PRD → Epic, gradual switching and rollback with traceable records.
Outsourcing/Remote Collaboration: Issues as project middleware, client and vendor can plug in/out anytime with transparent delivery.
Code Audit/Compliance: Complete “spec → code → commit → comment” chain, audit-friendly.

The author also shares design motivations and practical experiences in blogs and communities, worth reading.

3 Small Tips After Getting Started

Use “main thread” as command center: Only place goals, progress, blockers; leave implementation details to sub-agents’ contexts.
Leverage /pm:next: Switch to next most important Issue anytime, maintaining team rhythm.
Install Sub-issues first: After parent-child tasks are clear, burndown charts, daily reports, cross-person collaboration all flow smoothly.

Potential Pitfalls (Landmine Avoidance)

Works without extensions too, but parent-child hierarchy degrades to task lists; installing gh-sub-issue makes experience much smoother.
Don’t pile everything into main session: Let each agent “sweep their own doorstep” in their own context, main thread only makes decisions.

Conclusion

I summarize ccpm’s definition in 8 characters: specifications grounded, parallelism ordered. Not relying on slogans, but on commands and deliverables, speaking through action.

If you’re stuck with “lost context, parallel conflicts, invisible progress,” it’s worth trying immediately.

Which type of problem do you most want to solve with ccpm? Let’s chat in the comments.

Wire Claude Code into Cursor, VS Code, and JetBrains

Aug 24, 2025

Vibe Sparking

Introduction

Many people install Claude Code but only use it from an external terminal. In fact, it already integrates with mainstream IDEs: Cursor / VS Code / Windsurf / VSCodium / the JetBrains family. The benefits are immediate: one‑key summon, in‑IDE diff view, automatic sharing of selections and diagnostics — and after changes, you can review them with the IDE’s native comparison tools.

What You Get

Quick summon: Cmd+Esc (macOS) or Ctrl+Esc (Windows/Linux).

In‑IDE diff: cleaner before/after comparisons — no more scrolling terminals.

Auto‑share selection/current file context: Claude understands exactly what you’re looking at.

Auto‑share diagnostics (lint/syntax errors): Claude follows those red squiggles.
Insert file references: Cmd+Option+K (macOS) or Alt+Ctrl+K (Win/Linux) to insert @File#L1-99 quickly.

All of the above comes from the official IDE integrations.

VS Code (Cursor/Windsurf/VSCodium) One‑Step Setup

Install and connect

Open the IDE’s integrated terminal.
At the project root, run:

claude

VS Code and its variants will auto‑install the extension, then you can use everything listed above inside the IDE. If you start from an external terminal, type /ide to connect Claude Code to the current IDE.

Make sure the CLI works

VS Code: run Shell Command: Install ‘code’ command in PATH from the command palette. This stabilizes code . and IDE detection for Claude.
Cursor: run Install ‘cursor’ to shell from the command palette (you can also install code). If PATH ordering looks off, adjust priority.

Common config

Run /config → set Diff tool to auto to use the IDE’s diff view automatically.
From any external terminal, you can still use /ide to bind to the IDE session.

JetBrains (IntelliJ / PyCharm / WebStorm / GoLand…)

How to use

Open a terminal at the project root and run claude.
Go to Settings → Tools → Claude Code [Beta] and adjust:
- Claude command (e.g., claude, /usr/local/bin/claude, or npx @anthropic/claude).
- WSL users can set: wsl -d Ubuntu -- bash -lic "claude" (replace Ubuntu with your distro).
Supports Cmd+Esc/Ctrl+Esc quick summon, diagnostics sharing, and in‑IDE diff.

ESC doesn’t interrupt? In JetBrains, ESC may be bound to “switch focus back to editor”:

Settings → Tools → Terminal
Uncheck “Move focus to the editor with Escape,” or remove the “Switch focus to Editor” keybinding.
Apply Now ESC can properly interrupt Claude’s actions.

Remote Dev tips For JetBrains Remote Dev, install the Claude Code plugin on the remote host and restart the IDE.

Common Pitfalls and Quick Fixes

VS Code extension didn’t install
- Make sure you ran claude inside the VS Code integrated terminal.
- Ensure code/cursor/windsurf/codium CLIs are available and allowed to install extensions.
JetBrains plugin “does nothing”
- Ensure you started claude from the project root.
- Check the plugin status and fully restart the IDE (restart twice if needed).
- For Remote Dev, confirm the plugin is installed on the remote.
Workflow tips
- Open your IDE and run claude from the same project root to share paths and file context.
- Use /config to set diff=auto, and enable /vim mode if you like; both are recommended by the official “best practices.”

Your Quick Integration Checklist (Save This)

VS Code/Cursor

# 1) Use the integrated terminal
claude
# 2) From an external terminal, attach to IDE
/ide
# 3) VS Code: install 'code' into PATH (command palette)
Shell Command: Install 'code' command in PATH
# 4) Cursor: install 'cursor' into shell (command palette)
Install 'cursor' to shell

JetBrains

Settings → Tools → Claude Code [Beta]
- Claude command: claude or npx @anthropic/claude
- WSL: wsl -d Ubuntu -- bash -lic "claude"

Settings → Tools → Terminal
- Disable ESC focus steal: uncheck “Move focus to the editor with Escape,”
  or remove the “Switch focus to Editor” binding

A Small‑Team Rollout Pattern (Battle‑Tested)

PR‑driven: define the requirement → run claude on a branch to plan and make changes → review diffs in the IDE → test locally → open a PR.
Pair‑Agent: humans steer the plan; Claude executes; the IDE shows diffs and diagnostics in real time.
Same root, same context: always start from the project root so everyone shares identical paths and context. The above blends official “best practices” with our daily experience.

Conclusion

Installing the tool isn’t the goal — closing the human‑AI loop inside the IDE is. Today, connect Claude Code to your Cursor/VS Code/JetBrains and try the full loop: quick summon → in‑IDE diff → diagnostics sharing → PR. You’ll likely find: cleaner changes, fewer words, faster cadence.

Question: Where does your team struggle more — “understanding legacy code” or “safely changing a big module”? Which extra step would you want Claude to take inside the IDE? Share your thoughts.

Uzi Runs Multiple AI Agents in Parallel: Claude Code, Codex, Cursor CLI, aider, and More

Aug 23, 2025

Vibe Sparking

Uzi is a command-line tool that uses Git worktree + tmux to run multiple AI coding agents in parallel, each with its own dependencies and development port, then uses checkpoint to merge results to the main branch with one command.

Introduction

One agent slowly modifying pages, another simultaneously refactoring the backend, and a third writing tests. Multi-threaded progress efficiency far exceeds “queuing for models”. This is how Uzi works: same repository, branch isolation, parallel execution, visual monitoring, one-click merging. The official README provides complete installation, configuration, and workflow examples, with v0.0.2 released on 2025-06-03.

Why Try Uzi?

High-Concurrency Experimentation: Start 3-5 agents at once, each exploring different implementations or styles, then merge the best solution. True “Isolation”: Uses Git worktree to give each agent an independent branch and directory, preventing cross-contamination. Automatic Development Environment: Each agent automatically starts a dev server with assigned ports for real-time preview. Full Management: tmux manages sessions, uzi auto automatically “confirms” tool calls, ls -w shows real-time progress and diffs. One-Click Conclusion: checkpoint rebases and commits selected agent branches back to the current branch.

Industry observation: There are also container-based solutions for isolating parallel agents; Uzi takes the worktree route, which works smoothly in monorepos too. Recent InfoQ reports have highlighted comparisons between these two approaches.

Installation and Prerequisites (3-Minute Setup)

Dependencies: Git, tmux, Go, and your commonly used AI tools (like Claude, Codex, Cursor, aider, etc.).

# Install
go install github.com/devflowinc/uzi@latest

# Ensure GOBIN is in PATH
export PATH="$PATH:$HOME/go/bin"

1 Minimal Viable Configuration (MVP)

Create uzi.yaml in the root directory:

devCommand: cd astrobits && yarn && yarn dev --port $PORT
portRange: 3000-3010

Key Points

Include dependency installation in devCommand since each agent runs in an independent worktree and needs to install its own dependencies.
$PORT must be left as a placeholder; Uzi will automatically assign ports.
Official examples are also provided for Next.js / Vite / Django setups.

Recommended Workflow: From Task to Merge in 5 Steps

1) Parallel Start

uzi prompt --agents claude:3,codex:2 "Implement a REST API for user management with authentication"

Specify multiple agents and quantities; also supports random for random naming.

2) Unattended Operation

uzi auto

Automatically “confirms” tool calls and continuation prompts; just let it run.

3) Monitor Progress

uzi ls -w

Watch mode refreshes every second, showing AGENT/MODEL/DIFF/ADDR/PROMPT etc.

4) Mid-Course Commands

uzi broadcast "Make sure to add input validation"
uzi run "npm test"

Broadcast additional instructions; also run the same command across all agents (with --delete to close windows after completion).

5) Select and Merge

uzi checkpoint funny-elephant "feat: add user management API"

Rebase the matching agent branch to the current branch and commit with message.

Developer practice articles have also demonstrated similar checkpoint/kill usage patterns for customized pruning.

3 Implementation Scenarios

Scenario A | Frontend Multi-Style Exploration

Give one interface component to 3 agents: minimalist / Material / enterprise style. Each agent starts its own local port; you directly compare in multiple windows and checkpoint the best one with one click.

Scenario B | Refactoring Route Competition

Should backend authentication switch libraries? Should it be layered? Run 2-3 approaches in parallel, read diffs for complexity and ports for performance perception, choose the more stable route.

Scenario C | End-to-End Coordination

One agent writes API, one writes e2e tests, another writes documentation and examples. Finally, only merge the one that “runs through everything,” kill and clean up other branches anytime.

Differences from Container Parallelization Cheat Sheet

Uzi (worktree): Light, fast, Git native, suitable for same-repo multi-experiments; tmux-friendly.
Container Solutions: Stronger isolation, heavier operations, suitable for extreme scenarios with cross-language/system dependencies.
Industry Perspective: InfoQ points out that Uzi’s worktree isolation can prevent agents from interfering with each other in monorepo scenarios.

Common Pitfalls and Avoidance

Port Conflicts: Make portRange large enough and ensure ports aren’t occupied.
Duplicate Dependency Installation: Include npm/pip install in devCommand; each agent installs its own.
tmux Unfamiliarity: Recommend learning basic window/panel switching to improve visibility.
Cost and Noise: Parallel = more tokens; suggest starting with 2-3 agents for small tasks, then scaling up. (Empirical rule, combined with community discussions about “parallel mental load” reminders.)
Security and Keys: Don’t hardcode sensitive env into prompts; inject via environment variables.

One-Page Quick Reference (Bookmark This)

# Install
go install github.com/devflowinc/uzi@latest
export PATH="$PATH:$HOME/go/bin"

# Configure
# uzi.yaml: devCommand + portRange

# Parallel start
uzi prompt --agents claude:2,random:2 "Build a todo app with React"

# Unattended
uzi auto

# Monitor/broadcast/batch commands
uzi ls -w
uzi broadcast "Add error handling"
uzi run "npm test"

# Merge/cleanup
uzi checkpoint agent-name "feat: ..."
uzi kill agent-name | uzi kill all

Conclusion

Parallelization isn’t showing off. It’s a productivity tool that lets teams “take multiple correct paths simultaneously”. Integrate Uzi into your daily workflow, start with small-scale pilots, then expand to complex projects. Once you get it working, you’ll find it hard to go back to the old rhythm of queuing for models.

Discussion Question: Which project would you first split into 3 parallel routes? Why?

VibeTree Runs Multiple AI Agents in Parallel: Claude Code, Codex, Cursor CLI, aider, and More

Aug 23, 2025

Vibe Sparking

VibeTree = Parallel Git worktree development + persistent terminals + Claude Code one-click integration, no branch switching, no lost context, efficiency soars.

Introduction

Writing features, fixing production issues, then back to major refactoring… constantly git stashing, losing context back and forth is too painful. VibeTree, this open-source desktop application, combines parallel git worktrees, persistent terminals for each branch, and deep Claude CLI integration. One project opens N “clones”, each running its own tasks, each chatting with Claude.

Feature Highlights

Parallel Development: One repo, multiple worktrees, simultaneous feature/hotfix progress, goodbye stash.
Persistent Terminal Sessions: Each worktree has its own terminal, state never lost.
Claude CLI Integration: Direct claude command in each terminal, use /ide to connect VS Code/Cursor, file context aligned.
One-Click IDE Opening: Direct access to VS Code or Cursor from VibeTree.
Multi-Repo Tab Management: Multiple projects in parallel, smooth interface switching.
Cross-Platform: macOS / Windows / Linux, installation packages provided. Current latest version v0.0.1 (Alpha).

Small reminder: The repository Issues section contains user feedback on early problems, such as Windows Defender false positives, macOS 15.6 ARM64 packages marked as corrupted, etc. You might want to check before installation.

Why Use Worktrees? Better Than Multiple Clones/Frequent Branch Switching

One Repo, Multiple Directories: Each directory is a “working copy” of a branch, sharing .git, lightweight and non-interfering.
Zero-Cost Switching: Production emergency? Go directly to the hotfix working directory, feature branch unaffected.

Installation and Startup

Option A: Download Executable Package (Recommended)

Go to Releases to download:

macOS: .dmg (Intel & Apple Silicon)
Windows: .exe
Linux: .AppImage or .deb

Double-click to install.

Option B: Build from Source

# Install dependencies
npm install
# Development debug
npm run dev
# Production build
npm run build
# Package application
npm run package

These scripts are already configured in the repository.

Prerequisites: Git installed; for AI capabilities, recommend installing Claude Code CLI (npm one-liner, up and running in minutes).

5 Getting Started Scenarios (Sweet Workflow)

1) “Feature + Hotfix” Dual Track Progress

Create feature branch worktree, simultaneously create another hotfix worktree.
Each has a persistent terminal, each chats with its own Claude. No panic when production breaks.

# Create two working directories next to project root (example)
git worktree add ../proj-feature -b feature/checkout main
git worktree add ../proj-hotfix  -b hotfix/urgent   main

Principle: Worktree makes “one repository, multiple working directories” a native capability.

2) “Refactor + Validation” Parallel Run

A worktree does major refactoring; B worktree maintains clean baseline for comparison/regression anytime.
Open claude in both terminals, let AI help you “break down tasks + write tests.”

3) IDE Integration

In corresponding worktree terminal: claude → input /ide, instantly connect to currently open VS Code/Cursor.
Claude and IDE share the same project root directory, context consistent, communication more accurate.

4) Multi-Repo Parallel, Centralized Control

VibeTree’s Tab interface opens multiple repositories simultaneously, smooth switching without confusion.
Dark/light theme follows system, manual switching also available.

5) Making Claude Comfortable

claude ready to use in terminal; for personalized appearance, status bar, etc., use /config to adjust.

One-Minute Startup Checklist

# ① Install VibeTree (or build from source)
# ② Prepare two working directories (feature & hotfix)
git worktree add ../app-feature -b feature/payflow main
git worktree add ../app-hotfix  -b hotfix/checkout main

# ③ Open VibeTree: open a terminal in each worktree
# ④ Type claude in terminal; if IDE connection needed, type /ide

Now you can: write new features in feature; reproduce and fix production issues in hotfix.
Two spaces don’t interfere, two Claudes online simultaneously.

Roadmap and Known Issues (Transparent Expectations)

Roadmap: Will support Claude completion/input-required system notifications, mobile access to Claude Code, etc.
Alpha Status: Please follow Issues section discussions on Windows false positives, macOS ARM64 package “corruption” prompts, privacy documentation supplements, first-start guidance, etc.

Who Is It For?

Independent Developers/Small Teams: Multiple diverse requirements, must progress in parallel.
AIGC Workflow Players: Want to truly embed Claude into branches and terminals.
Operations and Emergency Response: When production alerts, switch to hotfix working directory, zero switching cost.

Conclusion

VibeTree isn’t rebuilding an IDE; it’s an OS-level tool that makes “parallel + AI” practical. Combining the underlying advantages of “one repository, multiple workspaces” with Claude’s upper-level intelligence into a replicable daily rhythm. You’ll be surprised: every day without branch switching is more focused.

What do you think is VibeTree’s most compelling feature? Let’s chat in the comments.

Claude Code Companion: One-Click Pool Switching, Third-Party Model Integration, and Observable Logging

Aug 22, 2025

Vibe Sparking

For those who constantly work with Claude Code, here’s a more stable and transparent “control center.”

Introduction

Coding with Claude Code is great, but unstable upstream endpoints, cumbersome switching, and inaccessible logs can be frustrating. Claude Code Companion packages all this into a local API proxy: drag-and-drop sorting for priority-based pool switching, automatic failover on exceptions, plus a visual management console and complete request/response logs. Even beginners can get up and running in 10 minutes.

Why It’s Worth Installing

1) Unstable? Auto-backup Kicks In

Supports multi-endpoint priority retry + failover. When one pool fails, it automatically switches to the next, and restores the primary when recovered. You’ll barely notice the disruption.

2) Opaque? Full-chain Observability

Built-in /admin management console lets you add/edit/delete endpoints, view real-time logs, and configure routing rules. Troubleshooting changes from “guessing” to “seeing.”

3) Incompatible? One Solution for All

Native Anthropic support, plus OpenAI-compatible entry points for services like OpenRouter, Volcano [Huoshan] Qianwen [Qianwen], Moonshot K2, GLM—just configure the default model name.

4) More Secure Default Practices

One environment variable to disable non-essential reporting/telemetry—a crucial feature for enterprises or privacy-conscious individuals.

Core Features at a Glance

Multi-endpoint load balancing + failover
Upstream response format validation (reconnects on non-compliance)
OpenAI-compatible model integration
Intelligent fault detection/recovery
Tag-based routing (by path, header, content)
Request logging + web management (/admin)

All features are documented in the official README.

10-Minute Quick Start (Beginner-Friendly)

Step 1: Download the Executable

Go to Releases and select your platform (Win/Linux/macOS Intel/ARM), then extract. Single-file execution, no external dependencies.

Step 2: First Run

Double-click or run from command line—a default config.yaml will be generated in the directory.

Step 3: Open the Management Console

Visit http://localhost:8080/admin in your browser. In the Endpoints page, add upstream endpoints (URL, authentication, type: Anthropic / OpenAI-compatible). Drag and drop to adjust priorities—takes effect immediately.

Step 4: Point Claude Code to the Proxy

In your Claude Code runtime environment, set:

# Essential: Route requests to local proxy
export ANTHROPIC_BASE_URL=http://localhost:8080

# Required but arbitrary: just needs to be non-empty
export ANTHROPIC_AUTH_TOKEN=dummy-token

# Recommended: Extend client timeout to avoid frontend disconnection from upstream timeouts
export API_TIMEOUT_MS=600000

# Recommended: Disable non-essential traffic (telemetry/error reporting/bug commands/auto-updates)
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

Note: Variables like ANTHROPIC_AUTH_TOKEN/CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC are documented in official docs or have equivalent configurations; BASE_URL routing for LLM gateways is also a standard practice provided officially.

Additional note: If you’re connecting to OpenAI-compatible gateways (like LiteLLM/OpenRouter), the official recommendation is the unified gateway address approach: export ANTHROPIC_BASE_URL=https://<your-gateway> (then configure token/default model).

Recommended Usage and Practical Scenarios

A. Multi-Pool Auto-Switching

Add multiple pools/upstreams in common → backup priority order via drag-and-drop sorting. Failed endpoints are automatically blacklisted and traffic routes to the next; recovery is detected in the background and restored. No need to restart the proxy or Claude Code.

B. One-Click Third-Party Model Integration

Services with Anthropic-format entry points (like GLM, K2): use directly as Anthropic endpoints.
Services with only OpenAI-compatible entry points (like OpenRouter, some domestic clouds): add as OpenAI-compatible endpoints and fill in the default model name.

This integration method is clearly documented in the README. Services like DeepSeek also provide direct Claude Code connection guides (setting ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, model name).

C. Tag-based Routing / A/B Testing

Dynamic routing to different endpoints based on request path, headers, or content—suitable for stability canary releases, cost routing, or scenario specialization.

D. Troubleshooting and Post-mortems

View real-time request/response logs in /admin, locate 4xx/5xx errors, timeout points, and format anomalies; supports endpoint blacklisting/recovery for observation.

Advanced: Using It as an “Enterprise LLM Gateway” Outpost

Working with LiteLLM/Self-built Gateways: Official documentation provides LLM Gateway solutions for unified authentication, usage tracking, cost control, auditing, and model routing. Claude Code connects via ANTHROPIC_BASE_URL.
More Granular Privacy/Telemetry Controls: CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 for one-shot control, or use DISABLE_TELEMETRY, DISABLE_ERROR_REPORTING, DISABLE_BUG_COMMAND, DISABLE_AUTOUPDATER variables for precise control.

Common Issues (Pitfall Checklist)

Q1: Claude Code not using the proxy? Check if ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN are set in the same shell; project-level settings.json can also inject unified env settings.

Q2: Third-party models returning 400/format errors? OpenAI-compatible endpoints must select “OpenAI-compatible” type and correctly set the default model name; the companion validates responses for Anthropic protocol compliance and triggers reconnection on non-compliance.

Q3: Can I use the built-in timeout controls? Yes. Increase API_TIMEOUT_MS to avoid frontend timeout causing false failure detection; Bash/MCP also have their respective timeout variables.

Risk and Compliance Reminders

Before using third-party gateways/pools, confirm service compliance, terms allow usage, and data won’t be misused.
Claude Code officially provides data usage options and non-essential traffic disabling—strongly recommended to enable.

Conclusion

Claude Code Companion’s positioning is clear: be your local “stable control center + transparent router”. Starting today, graphically manage endpoint management, model switching, and troubleshooting, making AI programming truly worry-free.

What other “automation features” do you think should be added? For example, cost-priority/speed-priority one-click switching? See you in the comments!

Appendix: One-Click Configuration Examples

macOS/Linux:

export ANTHROPIC_BASE_URL=http://localhost:8080
export ANTHROPIC_AUTH_TOKEN=dummy-token
export API_TIMEOUT_MS=600000
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
claude

Windows PowerShell:

$env:ANTHROPIC_BASE_URL="http://localhost:8080"
$env:ANTHROPIC_AUTH_TOKEN="dummy-token"
$env:API_TIMEOUT_MS="600000"
$env:CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"
claude

To integrate with gateways (like LiteLLM/OpenRouter), simply change ANTHROPIC_BASE_URL to the gateway address.

Claude Code Quietly Opened a '1M Context Window': /model sonnet[1m]

Aug 22, 2025

Vibe Sparking

Claude Code Quietly Opened a “1M Context Window”: /model sonnet[1m]

People online have reported that some Claude Code Max (20x) users can now use /model sonnet[1m] to switch to Sonnet 4’s 1M context. Anthropic has also officially confirmed that Sonnet 4’s 1,000,000 token long context is in public testing, but it’s primarily available on API / Bedrock first, with desktop and Claude Code gradually rolling out—some users may already be in “gray testing.”

Why Should You Care?

1M context means you can stuff an entire medium-sized codebase, dozens of technical documents, or a stack of contracts in for analysis all at once, with less chunking and back-and-forth. Official description: roughly 75,000 lines of code/dozens of research papers consumed in one go, 5x more than before. Currently marked as Public Beta (API, Amazon Bedrock available, Vertex “coming soon”).

Community testing is also increasing: media, blogs, Hacker News, and Reddit are all discussing it.

Who Can Use It Now? Can “Max 20x” Really Access It?

Official Confirmation: Sonnet 4’s 1M window is live on API as Beta, requiring beta header (context-1m-2025-08-07); Amazon Bedrock has integrated it; Vertex “coming soon.”
Subscription Side: Claude Max plan combines Claude App and Claude Code, advertised as “up to 20x” usage quota. This is what everyone calls “Max 20x.”
Community Feedback: Some users report that Max 20x subscription can already switch to 1M, but others get errors; likely gradual rollout or regional/account whitelist differences. Don’t rush, try first.

Summary: API has official confirmation; Claude Code/desktop is gradually scaling up. You may have been “quietly enabled” or still in the queue.

Three Steps to Try: Switch to 1M in Claude Code

Step 0: Update to Latest Claude Code

npm i -g @anthropic-ai/claude-code

Or

claude update

Refer to official Quickstart/CLI documentation.

Step 1: Execute in Session

> /model sonnet[1m]
  ⎿  Set model to sonnet[1m] (claude-sonnet-4-20250514[1m])

This is one of the valid options for built-in slash commands (community issue error logs directly list sonnet[1m]).

Step 2: Send Any Message Trigger an actual request to see if it succeeds. If it errors, don’t blame yourself—your account might not be up yet.

Step 3: Check Current Model/Status

/status

Use this to view account and system status, confirm if switched to 1M.

Advanced: Use CLI directly with model
Terminal window
claude --model claude-sonnet-4-20250514
But 1M mode usually requires server-side switches/whitelisting or corresponding beta capabilities, not guaranteed just by specifying.

Usage Recommendations: Getting Real Value from 1M

1) Whole-Repository Understanding & Refactoring Navigation Bundle README, architecture diagrams, core modules, key tests and feed them in for system-level mapping and refactoring plans. Media testing shows cross-file reasoning is more stable with long windows.

2) Large Document Batch Reviews Feed multiple technical specs/compliance documents/contracts at once for comparison and risk point lists, then have it provide change recommendations and trackable tasks.

3) Codebase-Change Impact Reviews Pull recent N PRs + dependency graphs, have it assess regression risks, generate test checklists, and supplement security/performance checks.

Practical tip: Long window ≠ omnipotent. Both official and developers remind: The larger the context, the more you need clear positioning and instructions, or it’s easy to “eat a lot but digest slowly.”

Cost and Performance: Don’t Let “1M” Empty Your Wallet

API Pricing: Over 200K input tokens are charged at long context rates; 1M in Beta is open to some organizations/quotas.
Claude Code Subscription: While not explicitly charged per token, larger contexts consume more quota/are slower. Recommend using /compact and CLAUDE.md for summaries and instruction constraints.

Common Errors and Troubleshooting

“Set successfully but errors on first message”: Common when account not enabled or regional rollout. Confirm you have Max (20x), try multiple times or different time slots.
“Command not recognized / invalid option”: Upgrade to latest version, check /model available list; community logs show sonnet[1m] already appears in selectable options.
API side won’t connect: Remember to add beta header: context-1m-2025-08-07.

Little Easter Egg: /model sonnet[1T] 😂

Want to make a joke, post a screenshot in the group pretending “1T context is now supported.” Don’t take it seriously, just for laughs.

Conclusion: Two Things to Do Now

One is update and try /model sonnet[1m]—you might already be enabled. Two is practice “long context usage habits”: clear goals, segment focus, regular /compact. When official full rollout happens, you’ll run faster.

What Do You Think?

How much improvement do you think 1M brings to real project delivery?
Do you prefer “consume everything at once” or “split—align—merge” workflows?
Have you gray-tested 1M yet? Feel free to comment with a /status screenshot (mind your privacy).

claude-code-proxy: Run OpenAI/Gemini Models with Claude Code

Aug 21, 2025

Vibe Sparking

“Translate” Claude Code requests to OpenAI or Gemini (or direct connect to Anthropic), zero code changes, one-command integration, supports streaming and automatic model prefix matching.

Introduction

Many developers want to use Claude Code’s workflow while leveraging OpenAI/Gemini’s model ecosystem and pricing structure. Switching SDKs, changing call formats, managing permissions and logging—lots of pitfalls.

This is where claude-code-proxy comes in: It allows Anthropic protocol clients (like Claude Code) to seamlessly connect to OpenAI/Gemini, or continue with Anthropic, while converting responses back to Anthropic format with complete frontend transparency.

Feature Highlights

Three backends with one-click switching: Set PREFERRED_PROVIDER to openai / google / anthropic. Don’t want mapping? Choose anthropic for direct connection mode.
Automatic model prefix handling: Automatically adds openai/, gemini/ prefixes to OpenAI/Gemini models, preventing typos.
Smart Haiku/Sonnet mapping: haiku → SMALL_MODEL, sonnet → BIG_MODEL; defaults to mapping to gpt-4.1(-mini) or gemini-2.5-pro / 2.0-flash.
Full LiteLLM backbone: Unified gateway, routing/fallback, usage tracking, budget limits, logging, and plugin extensions.
Complete streaming/non-streaming compatibility: Transparent to Claude clients.

Installation and Quick Start

Goal: Start a proxy on local port 8082 that Claude Code can point to directly.

1) Clone and install dependencies (using uv for speed)

git clone https://github.com/1rgs/claude-code-proxy.git
cd claude-code-proxy

# Install uv (one-time setup)
curl -LsSf https://astral.sh/uv/install.sh | sh

uv handles dependency resolution/installation based on pyproject.toml efficiently.

2) Configure environment variables

cp .env.example .env
# Edit .env and fill in your API keys, preferred backend, and models

Key items:

OPENAI_API_KEY, GEMINI_API_KEY, (optional) ANTHROPIC_API_KEY
PREFERRED_PROVIDER=openai|google|anthropic
BIG_MODEL / SMALL_MODEL (for Sonnet/Haiku mapping)

See README for details.

Gemini API Key can be created and configured as an environment variable with one click in Google AI Studio.

3) Start the service

uv run uvicorn server:app --host 0.0.0.0 --port 8082 --reload

--reload is suitable for development.

Integration with Claude Code

Install Claude Code:

npm install -g @anthropic-ai/claude-code

Official recommendation: avoid using sudo; see documentation for permission issues.

Point to proxy and launch:

ANTHROPIC_BASE_URL=http://localhost:8082 claude

After this, Claude Code’s Haiku/Sonnet will be mapped to OpenAI/Gemini or direct Anthropic connection according to your .env configuration.

Three Common Mapping Templates (Ready to Copy)

A. Default to OpenAI (Simple and Reliable)

PREFERRED_PROVIDER=openai
OPENAI_API_KEY=sk-...
# Optional: BIG_MODEL/SMALL_MODEL
BIG_MODEL=gpt-4.1
SMALL_MODEL=gpt-4.1-mini

Haiku/Sonnet → openai/SMALL_MODEL / openai/BIG_MODEL.

B. Prefer Gemini (Cost-Friendly/Fast Response)

PREFERRED_PROVIDER=google
GEMINI_API_KEY=...
OPENAI_API_KEY=sk-...   # As fallback
BIG_MODEL=gemini-2.5-pro-preview-03-25
SMALL_MODEL=gemini-2.0-flash

Haiku/Sonnet → corresponding gemini/ prefix; fallback to OpenAI when not in allowlist.

C. “Anthropic Transparent Proxy” Only

PREFERRED_PROVIDER=anthropic
ANTHROPIC_API_KEY=sk-ant-...
# Ignore BIG/SMALL, pass through to Anthropic

Benefits: Retain logging/middleware/unified entry point while avoiding mapping.

Why It’s Stable: LiteLLM Gateway Capabilities

Unified interface for 100+ models (OpenAI, Anthropic, Google, etc.).
Supports routing/fallback, load balancing, budget limits, and usage tracking.
Customizable logging, alerts, plugins for compliance and auditing.

Recommended Usage Scenarios

Team Gateway: Consolidate LLM traffic from Claude Code, scripts, and backend services through this proxy for centralized cost control and auditing.
Cost/Performance A/B Testing: One-click switching between OpenAI and Gemini to see which offers better cost optimization or inference accuracy.
Direct Anthropic + Enhanced Governance: Preserve real models and responses while reusing proxy’s logging and limit modules.
Local Development: Run port 8082 on development machine, Claude Code connects directly, zero project changes.
Multi-Model Fallback: Automatic fallback when OpenAI fails, ensuring uninterrupted development (via LiteLLM routing/fallback).

Common Pitfalls & Avoidance Checklist

Model Name Prefixes: Let the proxy automatically add prefixes to avoid mistakes like writing gpt-4o as gemini/gpt-4o.
Permissions and Keys: Gemini keys need to be requested from Google AI Studio; environment variables must be visible at runtime.
NPM Permissions: If Claude Code installation fails with permission errors, follow official guidance—don’t force sudo.
Port Conflicts: If 8082 is occupied, change --port.
Production Deployment: Recommend adding reverse proxy and authentication (like Nginx + Basic Auth), and enabling LiteLLM’s budgets/rate limiting/logging.

One-Minute Verification

uv run uvicorn ... successfully listens on 8082.
npm i -g @anthropic-ai/claude-code installs without errors, claude doctor passes self-check.
Run:
Terminal window
```
ANTHROPIC_BASE_URL=http://localhost:8082 claude
```
Initiate a simple conversation and observe proxy logs to confirm target model is hit.

Conclusion

claude-code-proxy lets you combine Claude Code’s productivity with OpenAI/Gemini’s cost-effectiveness and ecosystem together. Start the proxy today, switch models with one click, and immediately boost efficiency.

CodeGPT Brings Claude Code to VSCode, JetBrains, and Android Studio

Aug 21, 2025

Vibe Sparking

Install the CodeGPT extension to run Claude Code directly inside VSCode and JetBrains: see visual plans, pause anytime, and edit tasks on the fly. Course‑correct mid‑run and move faster. Android Studio and the JetBrains family are supported similarly.

Introduction

Still “chatting blind” with Claude Code in the terminal? There’s a smoother way: bring Claude Code into the editor UI.

With a UI you can see the plan tree, insert tasks, and undo changes. For complex tasks you don’t have to wait for the final output—correct course midway. This feels much closer to real pair programming.

Why run Claude Code with a VSCode UI?

Fewer detours: a visual plan reveals drift so you can pull it back quickly.
Intuitive controls: pause/continue/edit/add tasks with buttons. VSCode’s ecosystem already supports this style of UI.
Stay in your editor: code, Git, and tests side‑by‑side. CodeGPT focuses on multi‑model workflows and whole‑repo understanding.

Note: Anthropic also provides a VSCode extension and IDE integrations, but the core remains a terminal‑launched workflow; adding a UI enhances the experience.

Two‑minute setup

VSCode

Open the marketplace and install “CodeGPT: Chat & AI Agents”.

Sign in to your CodeGPT account (VSCode will open a browser confirm).
In CodeGPT, choose Anthropic as the provider and connect your key/account per the prompts.

Open the CodeGPT panel in the sidebar, select a Claude model, and enable the conversation with planning.

Tip: VSCode Marketplace (official): CodeGPT.

JetBrains (IntelliJ / PyCharm / Android Studio, etc.)

Install “CodeGPT: Chat & AI Agents” from the plugin marketplace, log in, and select Anthropic.

What does “controllable planning” look like?

In the VSCode sidebar conversation panel you’ll see:

Plan/Thinking mode entry points (plan first, then execute; raise thinking depth when needed).
Pause/continue controls for long flows.
Editable task list with insertable subtasks.
Checkpoints and restore, so missteps are reversible.

These patterns are proven in UI extensions for Claude Code in VSCode (e.g., “Claude Code Chat” demos plan/thinking/history/restore). CodeGPT has announced support for running and controlling Claude Code planning flows inside VSCode.

Three quick scenarios to try

1) Hotfix a bug (monorepo)

Prompt: “Find and fix the root cause behind the latest error logs. Propose a plan first, then change code with minimal blast radius, and include self‑test steps.”
After you see the plan, delete unnecessary subtasks and run.
Add: “Generate a diff preview before applying changes.” (easier reviews)

Planning‑driven workflows have proven effective for many developers.

2) Refactoring + automated tests

Ask for a refactor plan and a regression checklist, then apply in batches.
Insert a new task mid‑run: “Add a minimal unit‑test set for modified modules.”
If it drifts, pause immediately, edit the task tree, then resume.

3) From scaffold to runnable demo

Prompt: “Generate a minimal, runnable demo for stack X. List steps and directory changes, then create files incrementally with explanations.”
Add a task for Dockerfile/CI.
Finally, use checkpoints to compare and roll back between alternatives.

Practical tips

Plan first: have it produce a plan without touching code; execute only after you confirm.
Small steps: for each change, ask it to output a diff and commit message to keep rollbacks easy.
File context: use @filename or “Send selected file to chat” to raise accuracy.
Model choice: pick Sonnet/Opus for large projects or deep reasoning; smaller models for lightweight Q&A. CodeGPT can route across multiple providers.

Comparison: which style to pick?

Capability / Mode	CodeGPT + VSCode UI	Anthropic Official VSCode Extension	Pure Terminal CLI
Visual plans / pause/edit	Yes (UI panel)	Basic IDE/terminal integration	No UI (text only)
Multi‑model + knowledge	Yes (multi‑provider, KG)	Anthropic models only	Anthropic models
Learning curve	Low (market install)	Low (extension + CLI)	Medium (CLI)
JetBrains support	Yes (official plugin)	IDE integration available	Yes (terminal)
Best for	Teams that edit plans	Fans of official + terminal flows	Keyboard/automation

Sources: CodeGPT VSCode/JetBrains plugin pages; Anthropic IDE integration and VSCode extension pages; community UI extensions showing plan/thinking/checkpoint controls.

Security and compliance notes

Authorization: connect your Anthropic account/key as prompted by the extension.
Privacy: CodeGPT states SOC2 Type II; no training on your code; privacy mode available.
Billing: Claude Code usage bills to your Anthropic account; confirm quotas and team limits first.

Quick install links (official)

VSCode: CodeGPT: Chat & AI Agents (marketplace)
JetBrains: CodeGPT: Chat & AI Agents (plugin)
Anthropic docs: Claude Code IDE integrations / overview

Also noted publicly: CodeGPT supports running Claude Code and controlling the planning flow directly inside VSCode—this post reflects that UI experience.

Closing

Once Claude Code lives in your editor, you’re no longer “waiting to see what it does.” It’s like guiding a junior teammate: pause anytime, edit anytime, add tasks anytime. This is what great human‑AI collaboration looks like.

Where would you plug this into your team’s pipeline? What do you think?

Subscribe to Claude on iOS at Nigeria Pricing: Step‑by‑Step Guide

Aug 21, 2025

Vibe Sparking

Recently, many folks asked: “Claude Code is amazing, but I don’t have an overseas card, or the price feels high. Any easy, cheaper route?”
Yes. This is a practical, step‑by‑step guide to switch your Apple ID to the Nigeria region and top up with a gift card to subscribe to Claude at a lower price.

Get your phone and a little patience — follow along.

01. Why choose the Nigeria region?

In one word: price.

App Store pricing differs by country/region. Nigeria’s in‑app prices for Claude are significantly lower than US and many other regions. With a region switch plus gift card top‑up, it’s very cost‑effective.

Prices converted at an example rate of 1 USD ≈ 7.25 RMB:

Plan	Official (USD)	US iOS (USD)	Nigeria iOS (NGN)	Nigeria ≈ (USD)	Nigeria ≈ (RMB)	vs US iOS Savings	vs Official Savings
Pro	$20	$20	₦14,900	$9.68	¥70.2	$10.32 (-51.6%)	$10.32 (-51.6%)
Max (5x)	$100	$124.99	₦100,000	$64.94	¥471.8	$60.05 (-48.0%)	$35.06 (-35.1%)
Max (20x)	$200	$249.99	₦200,000	$129.87	¥942.6	$120.12 (-48.0%)	$70.13 (-35.1%)

Notes:

Pro: $9.68 × 7.25 ≈ ¥70.2
Max (5x): $64.94 × 7.25 ≈ ¥471.8
Max (20x): $129.87 × 7.25 ≈ ¥942.6

Actual rates fluctuate; check the store display on your date of purchase.

02. What you need

An iPhone or iPad.
A spare Apple ID (ideally newly registered; don’t disturb your main account to avoid affecting existing subscriptions/library).
Nigeria‑region Apple Gift Card (buy from a reliable seller).
An email and phone number from a Claude‑supported region (required for Claude registration/verification).

03. Switch your Apple ID to Nigeria

Open Settings → tap your profile.
Go to Media & Purchases → View Account.
Tap Country/Region → choose Nigeria.
Enter an address (e.g., a common Lagos address); set payment method to None.
After success, your Apple ID store is now Nigeria.

Apple may require zero balance, no blocking subscriptions, and leaving Family Sharing before switching. Follow on‑screen prompts.

04. Redeem a Nigeria gift card

Obtain the Nigeria App Store gift card code you purchased.
Open App Store → avatar → Redeem Gift Card or Code.
Enter the code → confirm → check balance credited to your Apple Account.

This is effectively your Nigeria store spending balance.

05. Register a Claude account

Go to claude.ai or the app and register.
Use an email from a supported region.
If SMS verification fails, use a phone number from a supported region (temporary numbers often fail fraud checks).
After verification, you can sign in.

In the Nigeria App Store, search “Claude” and install.
Sign in with your Claude account.
Open the subscription screen and choose a plan.
Pay with your gift‑card balance via Apple IAP.

Done 🎉 — you’re now on the discounted Nigeria pricing.

07. Notes and common pitfalls

Use a spare Apple ID: avoid disrupting your main account’s existing subscriptions/apps.
Buy gift cards from reputable sellers: avoid invalid/blocked cards.
Cross‑region always has policy and risk‑control considerations; Apple may change rules, taxes, or exchange handling.
Availability varies by region; if the app doesn’t appear or connect reliably, you may need a stable network/VPN.

Closing

Despite many steps on paper, the flow is quick: in about 10 minutes you can set it up — and save real money.
After subscribing, Claude becomes a powerful helper for coding, writing, summarizing, and ideation.

Give it a try and see how much you save each month.

Subscribe to Claude on iOS: Region Switch, Gift Cards, and In‑App Purchase Guide

Aug 21, 2025

Vibe Sparking

Goal: Successfully subscribe to Claude (Pro/Max) via the App Store on iPhone/iPad, with support for renewals and upgrades.
Who: Users in a Claude‑supported region who prefer Apple in‑app purchases.

Peace of mind: manage plans and cancellations in one place with Apple billing.
Safety: pay with Gift Cards/Apple Account balance without exposing your card number.
Sync: native iOS app with data unified with the web version.

Five Practical Steps

1) Register a Claude account (overseas email + supported‑region phone number)

Open claude.ai, register and sign in with your email. You will then be asked to verify your phone.
You must use a phone number from a Claude‑supported region; the official policy explicitly requires “a supported‑region phone number” to log in. (Avoid temporary numbers — they trigger fraud controls.)

Tip: Gmail/Outlook work fine. If the phone number was previously bound to another account, contact support to un‑bind the old number before re‑binding.

2) Switch your Apple ID country/region to a Claude‑supported region (e.g., US/Canada)

Go to Settings → your name → Media & Purchases → View Account → Country/Region and follow the flow.
Ensure these prerequisites before switching:
- Zero remaining balance;
- Cancel subscriptions that block region change and wait for the billing period to end;
- Prepare a payment method valid in the new region (Apple Account balance/Gift Card works).
If you are in Family Sharing, you may be unable to switch; leave the family group first.

Check accepted payment methods for the new region: see Apple’s official list (most regions accept Apple Account balance/Gift Cards).

3) Buy an Apple Gift Card for that region (commonly the US)

Gift Cards are strictly region‑locked: redeemable only in the country/region of purchase; cross‑region redemption is not supported.
Don’t buy the wrong card type: an Apple Store (retail) gift card cannot be redeemed in the App Store; buy an Apple Gift Card / App Store & iTunes card.
Double‑check denomination/region/card type match your Apple ID exactly; prioritize authorized channels.

4) Redeem the Gift Card on your iPhone

Open App Store → avatar → Redeem Gift Card or Code → enter/scan the 16‑digit code. After redemption, your Apple Account balance will show.

Balance notes: certain subscriptions/contexts have exceptions for balance usage; local rules prevail (most in‑app purchases can be charged to balance).

Search “Claude by Anthropic” in the App Store and install.
Open the app, sign in with your Claude account, choose a plan at the subscription screen, and pay via Apple IAP.
US pricing (subject to the store display):
- Claude Pro monthly $20
- Claude Pro yearly $214.99
- Claude Max 5x monthly $124.99
- Claude Max 20x monthly $249.99
  (Taxes/prices vary by country.)

One Table of Key Points

Step	Key Point	Common Pitfall
Register Claude	Supported region + phone verification	Temp/non‑supported numbers rejected; multiple binds require un‑bind
Apple ID switch	Zero balance, cancel subs, payment ready	Family Sharing blocks; leftover balance below one item’s price
Buy Gift Card	Exact region and card type	Buying an Apple Store (retail) card for App Store; wrong region
Redeem	App Store → avatar → Redeem…	16‑digit code mis‑typed/damaged; “redeem in another store” message
Subscribe	In‑app IAP, prefer balance	In a few regions, balance limits on some subs — follow local rules

(Official references: supported regions/phone requirements; region‑switch prerequisites; Gift Card region locking; redemption steps; payment methods and pricing.)

Risk and Compliance Notes (Read First)

Follow terms: Claude is available only to users in officially supported countries/regions; registration/login must comply with location and phone requirements.
No cross‑region Gift Card use: cards from the wrong region/type cannot be redeemed; Apple does not transfer balances across regions.
Region‑switch prerequisites: outstanding balance, active subscriptions, and Family Sharing can block switching. Follow Apple’s official flow.

FAQ | You Might Ask…

Q: I’m stuck with leftover balance when switching regions — what now?
A: Purchase digital items to zero out exactly; if the balance is below one item’s price, contact Apple Support.

Q: Can I pay for Claude with balance?
A: In most regions, in‑app purchases support Apple Account balance; a few regions/subscriptions have exceptions — follow local terms.

Q: Is the app available in my chosen store?
A: The Claude iOS app is available in supported regions’ App Stores, under Claude by Anthropic.

Closing | Make Claude Your “Pocket Workbench”

By now you’ve completed: supported‑region account → Apple region switch → Gift Card top‑up → in‑app subscription.
Next, turn Claude into your on‑the‑go copilot — writing, translation, notes, and image understanding all in one.

What do you think?

Which region will you set your Apple ID to, and why?
If you’ve tried Pro/Max, how does it feel in real use?

Claude Code `/context` Visualizes Context Window, Token Usage, MCP Calls, and Memory Files

Aug 21, 2025

Vibe Sparking

TL;DR: /context renders a visual snapshot of your current session’s context window, token usage, MCP tool traces, and loaded memory files (CLAUDE.md), so you can “trim, control, and detect leaks” with confidence. This feature appeared around Claude Code v1.0.86 based on community feedback and testing.

Introduction

Ever had a conversation suddenly get “auto-compacted,” scattering key info into folded chunks?

/context is like a “body-fat scale” for your conversation. It lays out what’s actually in the context, which parts are overweight, and why compaction triggered. It also highlights which MCP tools were used and which CLAUDE.md memory files were pulled in—perfect for targeted optimization.

Why use `/context`? (Quick highlights)

One-glance context view: See which segments are in the window, how many tokens each consumes, and how close you are to the limit. (Community notes: for a 200k window, auto-compaction often triggers around ~80% usage.)
Find the “heavy hitters”: Shows MCP usage and large files read via tools so you can slim down.
Verify memory: Surfaces loaded CLAUDE.md / CLAUDE.local.md so you can avoid overstuffed memory.
Cost awareness: Cross-check /context with a status bar or third-party tools (like ccusage) to spot silent drains. (Rough guidance seen: average daily cost around $6; 90% of users under $12.)

Note: /context metrics may differ slightly from other sources (auto-compaction prompts, ccusage, custom status bars). Treat it as a diagnostic view.

Five practical scenarios

1) Mid/late-stage “health check” for long threads

During a long-running task, run /context to see which passages consume the most tokens. Pair with /compact focus: {this week’s goals and deltas} for targeted slimming, so old detours don’t keep riding along. (Slash commands including /compact are officially supported workflows.)

2) Memory hygiene

If /context shows an oversized CLAUDE.md in your home or project, split wisely: keep standards and conventions in the project-level CLAUDE.md; put temporary preferences in CLAUDE.local.md; and reference large docs via excerpts instead of dumping them all in at once.

3) MCP auditing

Use /context to see which MCP calls hit search/DB/external APIs. Identify the most token-expensive call chains, then apply allowlists or rate limits. MCP is a first-class integration in Claude, ideal for connecting external tools at scale.

4) “Travel light” before a sprint or release

Before merging or releasing, run /context to confirm there’s no irrelevant conversation history or bloated memory inflating the window. Reducing clutter lowers the chance of auto-compaction and improves response stability. The “~80% triggers compaction” heuristic is a helpful reference.

5) Cost tracking with visual feedback

Mount ccusage in your status bar to watch current session/today/5‑hour block consumption. If you see a spike, open /context and line things up.

`/context` vs. other signals (at a glance)

Capability	`/context`	Auto-compaction prompts	`ccusage` (status bar)	Custom status bar
Granularity	Fine: segments/MCP/memory visible	Coarse: threshold only	Fine: real-time cost/tokens	Depends on script
Memory visibility	Yes: shows CLAUDE.md sources	No	No	Possible
MCP visibility	Yes	No	No	Possible
Accuracy	Early versions may vary slightly	Accurate	Accurate (billing/logs-based)	Varies
Best for	Diagnosis/optimization	Everyday use	Cost-sensitive workflows	Power users

Note: Accuracy notes reflect official/community docs and issue threads; /context continues to evolve.

Handy checklist (copy-paste ready)

Inspect context: Type /context and review large chunks and sources (MCP/memory/history).
Targeted slimming: /compact focus: "current iteration goals and blockers" to focus, then compact.
Memory governance: Put conventions in project CLAUDE.md; keep ad-hoc prefs in CLAUDE.local.md; split large docs by reference.
MCP allowlist: Allow only trusted tools to run automatically; require interactive approval when needed; add rate limits if necessary.
Cost linkage: Install ccusage and compare observations with /context regularly.

Gotchas

Numbers won’t always match: /context is still maturing and may differ from a status bar or auto-compaction prompts; treat billing/logs as the source of truth.
Don’t treat memory as a dumping ground: Memory files are auto-read; large ones will consume context. Control granularity.
MCP isn’t a free lunch: Each external lookup/read may incur extra tokens. Use allowlists and rate limits.

Closing

/context is your developer “context checkup sheet.” To use Claude Code more stably, efficiently, and cost‑effectively, make the invisible visible. From today, build three habits: check /context often, use /compact intentionally, and keep memory lean. You’ll see steadier responses, better cost control, and smoother collaboration.

What views would you add to /context? Do you have a “status bar + /context” combo you like? Share your setup and tips.

Seamless Switch: Claude Code × DeepSeek v3.1

Aug 21, 2025

Vibe Sparking

DeepSeek v3.1 adds Anthropic API compatibility. Point Claude Code’s BASE_URL and auth to DeepSeek and keep using Claude Code’s workflows and tools, while swapping the underlying model to DeepSeek for a similar experience at friendlier cost.

Introduction

Many folks ask: can we keep the full Claude Code experience — REPL, /config, permission sandbox, hooks, status line — but swap the underlying model to a more cost-effective one?

Now the answer is yes. DeepSeek v3.1 announced Anthropic-compatible APIs, making the integration straightforward.

What You Get

Seamless Claude Code integration: keep the CLI, project permissions, MCP/tooling; only change env vars and model names.
Friendlier pricing: DeepSeek Chat (v3.1) lists input $0.27 per 1M tokens (cache miss) and output $1.10 per 1M tokens. Compared to Claude Sonnet 3.7/4 at $3 / $15, input is about 1/11 and output about 1/13.6 — real savings.
128K context (v3.1) plus strict function calling (Beta). Great for code agents and tool orchestration.

Note: Anthropic is also pushing Sonnet 4 with 1M context (billed at higher tiers). That upper limit is an advantage DeepSeek doesn’t yet match — choose by workload.

3 Steps to “Claude Code × DeepSeek”

1) Install Claude Code

npm install -g @anthropic-ai/claude-code

(After install, run claude doctor to self-check versions and dependencies.)

2) Configure environment variables (official pattern)

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=${YOUR_API_KEY}
export ANTHROPIC_MODEL=deepseek-chat
export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat

Notes:

ANTHROPIC_BASE_URL points to DeepSeek’s Anthropic-compatible endpoint.
ANTHROPIC_AUTH_TOKEN is used as Authorization: Bearer ....
ANTHROPIC_MODEL and ANTHROPIC_SMALL_FAST_MODEL select DeepSeek’s model in Claude Code.

3) Enter your project and start

cd my-project
claude

You’ll still see the Claude Code interactive workflow, but requests go to DeepSeek.

Want to persist settings? Put the above vars into ~/.claude/settings.json under env. Project/global both supported for easy team rollout.

Practical Tips & Best Practices

A. Use settings.json to pin model and limits

{
  "model": "deepseek-chat",
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "sk-***",
    "ANTHROPIC_MODEL": "deepseek-chat",
    "ANTHROPIC_SMALL_FAST_MODEL": "deepseek-chat",
    "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "4096"
  }
}

This avoids repeated exports when starting new projects and helps teams standardize quickly.

B. Combine with an LLM gateway (optional)

You can point ANTHROPIC_BASE_URL to an internal LLM Gateway/LiteLLM to enable routing, circuit-breaking, cost dashboards, and quotas. Official docs support ANTHROPIC_BASE_URL and apiKeyHelper style configurations.

C. Cost optimization ideas

Unify small-task model: set ANTHROPIC_SMALL_FAST_MODEL to DeepSeek (used for scan/retrieval/light reasoning by default).
Cap output: tune CLAUDE_CODE_MAX_OUTPUT_TOKENS to prevent long outputs from consuming too many tokens.
Function calling: v3.1 supports strict function calling (Beta) to drive structured toolchains and reduce detours/token waste.

Compatibility Gotchas to Avoid Early

DeepSeek’s Anthropic compatibility layer covers common fields like messages, tools, streaming, temperature, top_p, etc. It also notes unsupported content types (e.g., image, document, search_result, and some MCP/container fields). For those needs, either switch back to Claude for that task or adjust prompts/flows.

Also remember sensitive file isolation. Use Claude Code’s permissions.deny to hide .env, secrets/**, etc., preventing model reads.

How Much Cheaper Is It?

Item	DeepSeek Chat (v3.1)	Claude Sonnet 3.7/4
Input (per 1M tokens)	$0.27 (cache miss)	$3
Output (per 1M tokens)	$1.10	$15

Bottom line: input about 1/11, output about 1/13.6. If you’re doing code refactors, retrieval, unit-test generation, the savings show up fast.

Best Fit

Individuals/SMBs: budget-sensitive but want engineering efficiency and stable tooling.
Agent/automation projects: frequent calls, predictable responses; prioritize cost control.
Education/experiments: keep the same Claude Code UX while quickly evaluating different model strategies.

FAQ

Q: The REPL still shows “Claude” — is DeepSeek actually running?

A: Yes. The shell is Claude Code, the engine is DeepSeek. Requests go to DeepSeek per your ANTHROPIC_BASE_URL and auth settings.

Q: Do I need to change SDKs?

A: Not if you use the Claude Code interactive workflow — just set env vars. If you call from code, you can use the Anthropic SDK and set BASE_URL to DeepSeek’s Anthropic endpoint.

Q: Any differences in the compatibility layer?

A: Yes. DeepSeek lists ignored/unsupported headers and message types. Tools are mostly supported, but image/document message types aren’t yet — plan accordingly.

Wrap-up

Saved cost is real runway. Keep Claude Code’s productivity, swap the expensive model for DeepSeek where it fits. Make the switch today; your month-end bill will thank you.

Want a ready-to-use ~/.claude/settings.json template and a simple cost calculator? I can draft one for your project.

Quick Copy Area

One-shot env setup (paste into shell)

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=sk-deepseek-***
export ANTHROPIC_MODEL=deepseek-chat
export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat
claude

From DeepSeek’s official guide and Claude Code env docs.

Python (Anthropic SDK pointing to DeepSeek)

pip install anthropic
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_API_KEY=sk-deepseek-***

import anthropic
client = anthropic.Anthropic()
msg = client.messages.create(
  model="deepseek-chat",
  max_tokens=800,
  messages=[{"role":"user","content":"Hi, from DeepSeek via Anthropic SDK!"}]
)
print(msg.content)

Turn Claude Code into a Productivity Dashboard with ccstatusline

Aug 20, 2025

Vibe Sparking

ccstatusline turns Claude Code’s bottom status bar into a “visual cockpit” — model info, Git branch, tokens, context usage, session time, and a 5‑hour block progress bar at a glance. You can even embed your own command outputs.

Introduction

For daily coding, two worries dominate: runaway cost and context blow‑ups. Claude Code now supports a custom statusline — a perfect home for a live dashboard.

ccstatusline is built for exactly this. It shows model, tokens, and context % out of the box, ships with Powerline themes, and most importantly, includes a Block Timer to visualize the 5‑hour window.

Why ccstatusline

1) See your 5‑hour block — with a progress bar

Auto‑detects conversation block boundaries and elapsed time;
Two progress‑bar styles (32/16 chars);
Raw value mode supported.

Rhythm matters: you’ll know when to pause and when to reset.

2) Powerline themes + truecolor

Arrow separators, customizable caps, multiple built‑in themes;
16/256/TrueColor all supported.

Looks great, packs information, blends with your terminal theme.

3) Zero‑learning TUI config

npx/bunx to open an interactive config UI;
Up to 3 independent lines; WYSIWYG;
Settings saved to ~/.config/ccstatusline/settings.json.

4) Bring any custom command

If it prints, it fits;
Plug in ccusage to show real‑time cost/usage.

Example: npx -y ccusage@latest statusline — docs include best‑practice flags.

5) All the key signals while coding

Model, Git branch/changes, input/output/cache tokens, context length and %, session clock, version, output styles, smart width truncation — the “signal among noise” for focused coding.

3‑minute setup

Install and launch

# Configure via npm
npx ccstatusline@latest

# Or bun (faster)
bunx ccstatusline@latest

In the TUI, add/reorder items, tweak colors, separators, and padding, then write into Claude Code settings.

Tip for VSCode terminal colors: set terminal.integrated.minimumContrastRatio to 1.

Suggested items

Model / Tokens Total / Context % (available) / Session Clock / Block Timer (progress bar) / Git Branch + Changes. For width, “Full width minus 40” helps avoid over‑compression.

Advanced: visualize “cost” and “rhythm”

A. Plug in ccusage — know where money goes

Add a Custom Command in ccstatusline: npx -y ccusage@latest statusline
Set timeout to 5000 (first install may take time).
Check “preserve colors”.

You’ll see session cost, daily total, current block cost and remaining time, and live burn rate.

Heads‑up: with older ccusage or slow networks, you may hit OOM/repeat calls — set timeouts and upgrade.

B. Custom commands: surface “out‑of‑context” signals

Current dir: pwd | xargs basename
Node version: node -v
Current commit: git rev-parse --short HEAD
Time: date +%H:%M
Weather: curl -s wttr.in?format="%t"

Make sure commands are fast — slow ones get killed by the refresher.

C. Multi‑line layouts for clarity

Line 1: model, tokens, context;
Line 2: git, dir, time;
Line 3: block progress, cost (ccusage).

Layered info + smart truncation keeps noise at bay.

Recommended scenarios

Cost control: pair with ccusage to watch live burn and block cost — great for personal and team reviews;
Long‑haul tasks: Block Timer supports natural focus/break pacing;
Team consistency: built‑in themes unify look and metrics for pair/review;
Demos/streams: the statusline narrates context and cost in real time;
Cross‑platform: runs on Bun/Node; Windows improvements are tracked via docs and feedback.

Pitfalls and fixes

Commands must be fast: slow custom commands will be terminated; they also slow refresh;
VSCode color oddities: set min contrast to 1 or use an external terminal;
Width wrapping: use “Full width minus 40” or switch layouts by context thresholds;
ccusage performance: set timeout, upgrade, or run standalone for health checks.

Closing

Don’t bury critical coding signals inside commands, files, or memory. Spread them on the statusline. See clearly, spend wisely, code steadily.

Fire up the “visual cockpit” and give Claude Code real instrumentation. npx ccstatusline@latest — ship it today.

The Everyday AI Stack: 7 Tools for Max Productivity at Minimal Cost (Aug 2025)

Aug 19, 2025

Vibe Sparking

After a month of swapping models back and forth, I settled on a daily setup that balances performance × price × speed. The goal is simple: practical, reusable, and cost‑controlled. Here’s the exact stack and workflows I use daily — and recommend to teams and family.

🚀 1) Work code: Claude Code 200u (heavy‑duty development)

Highlights

Run Claude directly in the terminal for transparent, controllable development; Pro/Max subscriptions connect web/desktop/mobile and the CLI.
With Opus 4 / Sonnet 4, it sustains long‑chain tasks and complex projects with strong iterative coding ability.
Anthropic notes subscription perks like more usage, daily‑tool connections, and extended reasoning — a good fit for engineering workflows.

Practical notes

Some vendors have introduced weekly throttling/anti‑abuse rules. For heavy use, stage long‑running tasks and save snapshots to avoid disruption.

Best for

Multi‑task monorepos, cross‑service refactors, and generate‑debug‑regress cycles.
Engineers who prefer to “orchestrate AI from the terminal.”

Quick start tip

Plan with Sonnet 4; execute mostly with Sonnet 4/Opus 4 as guardrails. Split work into 30–60‑minute sprints and persist artifacts between stages.

🌐 2) Communication & translation: claude‑sonnet‑4‑20250514 (pin the snapshot)

Why a precise version? Anthropic recommends pinning to a specific snapshot (e.g., claude-sonnet-4-20250514) in production to avoid behavior drift from alias updates.

Best for

Bilingual email, PR statements, and localized product copy.
Meeting notes that need consistent tone and logic.

Quick start tip

Provide audience profile + comms goal first. Then ask for three rewrites (formal/friendly/minimal) and extract a glossary to unify terminology.

📖 3) Reading translation: OpenAI GPT‑4.1 nano (lighter is faster)

Highlights

Very low latency and cost — ideal for short texts and light processing.
1M‑token context is great for bulk organization and side‑by‑side translation.

Best for

PDF summaries, paragraph‑level aligned translations, annotated notes.
Rule‑based rewrites: titles, abstracts, key‑point cards.

Quick start tip

Let nano handle structured extraction + light polishing. Hand heavy rewrites and stylistic lifts to higher‑tier models — cheaper and more stable overall.

🎙️ 4) Speech‑to‑text: ElevenLabs Scribe v1

Highlights

99 languages, word‑level timestamps, speaker diarization, and audio event tags (laughter/applause).
Positioned as high‑accuracy ASR, robust for noisy environments and multi‑speaker meetings.

Best for

Remote meetings, interviews, podcasts, call recordings.
Legal retention and training materials.

Quick start tip

Use API with model_id=scribe_v1. For long audio, chunk while preserving timestamps to align playback later.

🧽 5) Post‑edit transcripts: OpenAI GPT‑4.1 mini

Why mini?

Compared with nano, mini follows instructions and reorganizes text more reliably. It’s stronger for formatting key points, summaries, and action lists; pricing/docs favor lightweight reasoning.

Best for

“ASR → structured minutes → todo list/email drafts.”
Extract decisions/risks/owners from Scribe output.

🔎 6) Web/research: Gemini × Claude × Grok — use all three

Each shines at something

Gemini: Google Search Grounding + Deep Research for web‑grounded, auditable sources and systematic investigations.
Claude: subscription includes Research; great for read‑ask‑write across projects/docs.
Grok 4: built‑in real‑time search and native tool calls — strong on timeliness and X‑ecosystem tracking.

My flow

Gemini to map the space and list key sources;
Claude to read long docs and produce a structured draft;
Grok to watch hot updates and last‑24‑hour changes.

👪 7) Family everyday: ChatGPT Plus ($20; Memory is the moat)

Why Plus for family

Affordable and sufficient models; official guidance is clear.
Memory can be toggled/cleared/managed — gets more helpful over time.
Recent updates improved cross‑chat memory and personalization, ideal for family schedules, homework help, and reminders.

Best for

Family lists, school notices, travel templates.
“Kid‑voice rewrites” and “elder‑friendly instructions.”

🧪 A reproducible daily workflow

Before → During → After meetings

Before: Gemini Deep Research for a 30‑minute pre‑read with sources.
During: live transcription via Scribe v1.
After: GPT‑4.1 mini for minutes and action items; Claude Sonnet‑4‑20250514 for external emails.

Dev → Test → Release

Claude Code 200u for refactors and long‑chain tasks;
Use nano to batch format and extract labels from stage artifacts;
Sonnet 4 to finalize release notes and changelogs.

⚠️ Risks and gotchas

Usage limits: heavy development should watch for throttling — stage runs and snapshot often to avoid interruptions.
Version pinning: pin API models to snapshots to prevent alias drift and unstable results.
Privacy & Memory: when family uses ChatGPT Memory, know how to disable/clear it anytime in settings.

🧰 Quick‑use checklist

Code long‑runs: Claude Code (Opus/Sonnet 4 combo).
Precise external comms: Sonnet‑4‑20250514 snapshot.
Lightweight reading/batch work: GPT‑4.1 nano.
Meeting ASR: Scribe v1.
Minutes & email: GPT‑4.1 mini + Sonnet 4.
Three‑way web research: Gemini Grounding / Claude Research / Grok 4.
Family assistant: ChatGPT Plus (Memory on).

✅ Conclusion

A good AI stack should swap “time anxiety” for “steady delivery.” This setup is what my team and I actually use. Trim it to your needs; start with one end‑to‑end workflow, then expand.

Which one is your strongest single pick? Want a follow‑up with “cost‑saver tips + ready‑to‑use config files”?

Claude Code, Cursor, GitHub Copilot Subscriptions Too Expensive? Maybe It's Time to Learn from TikTok

Aug 18, 2025

Vibe Sparking

Claude Code, Cursor, Copilot Subscriptions Too Expensive? Maybe It’s Time to Learn from TikTok

How Mainstream AI Programming Assistants Make Money

Current popular AI programming tools like GitHub Copilot, Cursor, and Claude Code primarily follow subscription-based business models with monthly fees. These tools are also experiencing rapid user growth:

GitHub Copilot (Microsoft GitHub): Individual subscription around $10/month, providing code auto-completion and chat features. Since launching in 2021, it has gained massive popularity, with over 20 million users having tried Copilot by 2025 (all-time users). Paid users exceed 1.8 million (as of early 2024). Copilot is also popular in enterprise - Microsoft CEO Nadella revealed that 90% of Fortune 100 companies use Copilot. With subscription pricing, Microsoft also bundles it into more expensive enterprise packages. Leveraging the massive developer ecosystem, Copilot’s revenue growth is rapid - in 2024, Nadella said its “business scale has exceeded the entire GitHub when Microsoft acquired it in 2018.”
Cursor (developed by Anysphere): An AI code editor built on VS Code, using a freemium model. Individuals get free Hobby version (with two-week Pro trial) and paid Pro version ($20/month); power users have $200/month Ultra tier with higher usage limits and priority new features. This pricing is quite affordable, leading to explosive Cursor user growth. Early 2025 reports suggested Cursor daily active users exceeded 1 million, with annualized recurring revenue around $200 million; months later its ARR climbed to $500 million - stunning growth showing many users willing to pay. However, Cursor team faces escalating costs as users grow. Reports indicate many AI programming companies have near-zero or negative gross margins due to high model inference costs, with “all code generation products having either zero or negative profit margins.” Despite Anysphere reaching $500 million ARR by June 2024, becoming one of the fastest SaaS companies to break $100M ARR, high compute costs pressure profits, forcing pricing strategy adjustments to shift some excess usage costs to heavy users.
Claude Code (launched by Anthropic): Anthropic integrates its advanced Claude model into terminals and IDEs, creating this AI programming assistant. Claude Code doesn’t charge separately but is included in Claude.ai subscription plans: individual Pro plan $20/month (about $17/month annually), subscription includes Claude Code access. Higher-tier Max plans at $100/month (5x usage) or $200/month (20x usage) provide larger context windows and stronger models (Claude Opus 4.1). In other words, Claude Code follows a “subscribe for AI service, get tools included” approach, using valuable coding assistants to attract developers to subscribe to AI services. Anthropic also offers usage-based API pricing for enterprises. Claude Code emphasizes deep code understanding and cross-file editing, receiving good feedback from professional development teams. However, compared to Copilot and Cursor, Claude Code user scale data is less public, possibly because it mainly targets paid user groups, using refined operations rather than broad-net strategies.

Overall, these AI programming assistants primarily use subscription monetization, ranging from tens to hundreds of dollars monthly, targeting the market where programmers pay for efficiency. Free users either cannot access features (Copilot discontinued free trials) or face significant limitations (Cursor free version has usage limits). While this business model is direct, it means no payment equals no full functionality. Could there be alternative approaches using common internet advertising/entertainment monetization methods to create new revenue streams for these AI tools? Before discussing this idea, let’s examine how short videos, live streaming, gaming and other sectors “make money.”

Short Videos, Live Streaming, Advertising: Internet’s Golden Money-Making Playbook

In the internet industry, user attention is hard currency. Short video platforms, live streaming, advertising distribution, and mobile games all achieve commercial value by capturing user attention for extended periods:

Short Videos (Douyin/TikTok): Through precise algorithmic recommendations, users scroll videos endlessly, enabling interspersed feed advertising for efficient monetization. Taking Douyin as example, by 2024 its monthly active users reached 1 billion (China only). Users spend average 110 minutes daily on Douyin, nearly equivalent to watching a full movie! With long user engagement, ads get ample display opportunities. Douyin’s advertising revenue soars, projected to reach $30 billion in 2024 (including splash screens, feeds, stickers, etc.). Additionally, Douyin integrates live commerce and e-commerce traffic, expanding monetization scenarios - statistics show over 40% of daily active users watch or participate in Douyin live commerce. Short video platforms dramatically increase user stickiness through algorithms + content, exchanging massive user time for high advertising revenue.
Video Websites (YouTube): As traditional long-video platform, YouTube’s main revenue also comes from ad insertion and creator revenue sharing. YouTube has 2.49 billion monthly active users globally, with 2023 advertising revenue reaching $31 billion. Average users spend nearly 49 minutes daily watching YouTube. The platform profits through pre-roll, mid-roll, and recommended page ads, then shares revenue with content creators. This model validates the logic that “as long as users watch long enough, ads will sell.” Recently YouTube introduced Shorts and live streaming, further increasing user engagement and enriching ad inventory. Video platforms use massive content to retain users, then monetize through advertising - a mature and efficient business logic.
Live Streaming Platforms (Twitch, etc.): Live streaming stimulates user enthusiasm through real-time interaction, beyond advertising, also driving user donations and subscriptions. Amazon’s gaming live streaming platform Twitch achieved 20.8 billion hours of total viewing time in 2024, with about 240 million monthly active users globally and 35 million daily active users. Half of Twitch’s revenue comes from advertising (ads inserted in streamer broadcasts, platform shares with streamers), half from user subscriptions and gift donations. Twitch generated approximately $1.8 billion revenue in 2024. Though smaller user base than short videos, dedicated viewers willing to pay for favorite streamers means higher ARPU (Average Revenue Per User). Live streaming monetization centers on strong community atmosphere: real-time chat, emotional connections between fans and streamers all increase user payment willingness. This model proves that even without short video-scale mass appeal, strong stickiness and deep interaction can generate considerable revenue.
Mobile Games and Interactive Games: Many games, especially free mobile games, monetize through in-app purchases and advertising. On one hand, few paying players (“whales”) contribute purchase revenue, on the other hand, many non-paying players become advertising monetization targets by watching ads for in-game rewards. Some casual mobile games design “watch 30-second ad for coins” mechanics, or insert ads during level loading. This “exchange waiting time for revenue” approach is common. Statistics show 2024 global mobile gaming market revenue exceeded $111 billion, with advertising revenue comprising significant portion. Google even launched App Open Ads specifically for displaying ads during app loading screens, letting developers monetize user waiting seconds. Gaming industry deeply understands this: monetize fragmented time, not wasting any moment users stay on screen.

In summary, whether short videos or live streaming, the underlying business logic is using excellent content or interactive experiences to keep users on platforms as long as possible, then monetizing user attention through advertising or value-added services. Can this logic transfer to AI programming assistants? Could we envision a model where programmers watch customized short videos or interactive content during AI coding breaks, using entertainment advertising revenue to replace part of subscription fees? This sounds far-fetched, but let’s boldly brainstorm.

Can You Watch Videos While AI Writes Code? Feasibility Analysis

Imagine a typical scenario: programmer Zhang uses AI assistant in VS Code to generate code, sometimes waiting several seconds for model results. These few seconds of downtime currently mean staring at “Thinking…” cursor. What if Zhang could see interesting content during these gaps, utilizing fragmented time?

Technically, this isn’t impossible. AI programming tools typically exist as plugins or standalone applications - Copilot is IDE plugin, Cursor is VS Code-based standalone editor, Claude Code runs in terminal/IDE. These tool interfaces could easily reserve small windows to push content during AI request processing. Similar to loading tips on web pages or mobile game loading screens, except here it could be personalized video/information feeds.

The key is what content to push that’s both engaging and non-disruptive to work? Learning from short video and content recommendation experience, ideal approach is precise interest matching. AI assistants already understand user code and context - with user authorization, they might guess user interests based on coding themes. For example:

When users write Python code for unit testing, small window pushes “3 Tips for Improving Test Efficiency” short video, 30 seconds perfectly matching current task.
During debugging downtime, push programmer humor short videos or funny memes, making users smile and relieving frustration.
Based on user preferences (like frequently reading frontend articles), recommend related tech influencer live clips or new product launch segments, keeping users updated on industry trends.

Of course, implementing smart recommendations requires building content recommendation algorithms. Could reference TikTok’s multi-layer machine learning models, rapidly iterating recommendations based on user behavior. AI programming assistants already call large models to understand code context, could combine with user-set interest tags for content filtering. Let users check preferred content types in settings: “Tech tutorials / Tech news / Comedy / Gaming streams / …” then assistant selects pushes accordingly.

More importantly, controlling frequency and format. Programmers need focus for coding, can’t let popup content overshadow main functionality. Ideal design is embedded: editor sidebar shows small muted video window, or output area displays news feed cards. After AI response generation, content auto-collapses without interrupting user flow. Google’s App Open Ads emphasizes choosing natural timing (like loading screens) for ad display, avoiding core experience disruption. Similarly, AI assistant content pushes should only occur during natural pauses like model computation or code compilation, with one-click close option.

For monetization, these pushed contents could include advertising elements. For example, pushed short videos feature vendor-promoted new developer tools (presented as content marketing), or live streams embed product links (users might need technical books/courses). Bing Chat already experiments with embedding ad links in chat answers, Microsoft states will share ad revenue with content providers. This shows integrating advertising into AI responses/interfaces is viable commercial attempt. In coding assistant scenarios, advertising could be more subtle and relevant: when users use free AI assistant for frontend code, small window recommends “more efficient frontend debugging tool” (actually advertising partnership promotion), users click if interested or skip if not, experience similar to seeing ads on TikTok.

Any Precedents? Industry Exploration and Comparisons

This “AI programming + entertainment advertising” model currently lacks direct mature cases, but related explorations exist:

Developer Community Advertising Attempts: Traditional programming Q&A sites like Stack Overflow historically monetized through page ads and enterprise recruitment ads. Though not AI tools, this shows developers aren’t completely ad-averse, provided ad content is highly relevant and doesn’t interfere with getting answers. Similarly, if AI assistants push developer-related news or products (like cloud service promotions, tech conference live previews), users might welcome them, even finding them educational.
AI Chat and Advertising Integration: Microsoft’s new Bing (Bing Chat) already inserts sponsored links in GPT-4 powered chat answers, sometimes including product ad cards for shopping queries. This essentially embeds search advertising directly into conversations. Though coding assistant scenarios differ from search, Bing’s practice proves large model responses and commercial advertising can coexist. Key is transparent labeling and relevance, letting users clearly identify ads while ensuring ads truly match their needs.
AI Tool Extension Windows: Some programming tools already show signs of news pushing. For example, JetBrains IDE shows “Tip of the Day” on startup, VS Code welcome page often has recommended articles or update announcements. These are embedded information content within tool interfaces, just not yet commercialized. If these windows became customizable content streams, it would be technically natural.
Free Models and User Scale: Currently some AI programming tools take free routes to attract users, then seek other monetization. For example, open-source Codeium is free for individuals, using data to improve models then charging enterprises later. But no clear “free + advertising” cases exist. On one hand, developer user base is much smaller than consumer apps, whether advertising monetization can cover high compute costs is questionable. On the other hand, programmer users demand higher product purity, rashly adding ads might cause backlash. So most startups choose direct subscription fees or enterprise payment rather than prioritizing advertising models.
Domestic Developments: Worth noting, domestic tech giants are also advancing AI coding assistants, like Alibaba’s “Tongyi Lingma.” According to Alibaba’s 2025 financial report, Tongyi Lingma (coding assistant) achieved strong revenue growth. However, it mainly targets enterprise customers, representing successful B2B paid model, different from our discussed C2C entertainment advertising approach. Tencent states AI technology has contributed to its performance advertising and gaming businesses, indirectly proving AI and advertising integration potential.

Overall, currently no direct products fusing programming assistants with entertainment content monetization, but from search chat to app loading ads to various successful freemium models, many borrowable elements exist. If some team dares break conventions, launching such “code writing + video watching” crossover product, it might truly open new blue ocean.

Future Outlook: AI Programming Assistant Entertainment Path

Imagine future development scenarios: you sit at computer writing code, AI assistant helps debug. During compilation breaks, it thoughtfully pushes “Today’s Programming Joke” short video for entertainment, or pops up AR real-scene hacker mini-game for few seconds of brain relaxation. This might sound absurd, but isn’t impossible. As new generation developers gradually adapt to multitasking and fragmented information streams, this work-entertainment intertwined mode might be more popular than imagined.

Commercially, “AI programming + entertainment advertising” model could bring win-win:

For individual developers, lower entry barriers - maybe no expensive subscription fees needed, just free access to powerful code AI tools, only tolerating some well-timed content pushes as exchange. Same logic already accepted in mobile apps (many apps offer “watch ads to unlock premium features” options).
For platform vendors, diversified revenue sources, shared compute costs. Current AI programming assistant profitability challenges largely stem from each additional user means additional compute costs, unlike traditional software where expansion doesn’t increase marginal costs. Introducing advertising monetization means even non-paying users generate revenue through ad viewing, helping subsidize model inference costs, alleviating “more users, more losses” predicament. This could make business models more sustainable.
For advertisers, new channel reaching programmer demographics. Programmers as high-consumption, high-decision-influence group have always been desired but hard-to-reach audience for many B2B and tech product advertisers. If programming scenario native ad placements exist, promoting cloud services, development tools, IT books/courses and other vertical products could have higher conversion rates than random TikTok advertising. Especially combined with AI understanding of user code intent, ad precision would improve significantly (provided privacy permissions and careful balance, otherwise easily causing backlash).

Of course, this path faces considerable challenges. First, not affecting user experience is biggest test. Programmers need long-term focused thinking, frequent entertainment content popups would interrupt flow. If content quality is poor or irrelevant, users would rather close assistant than be disturbed. Therefore content recommendations must be sufficiently personalized and valuable, ideally inspiring work (like recommending related technical solution video tutorials, more acceptable than pure commercial ads). Simultaneously need complete user control, like setting “focus mode” with no content pushes, or allowing paid ad removal (like many apps’ “remove ads pro version”).

Second, scale effects are problematic. Global developer numbers are large but far from entertainment app user bases. To rely on advertising monetization, per-user ad revenue must cover model inference costs, requiring improvements in both ad effectiveness and compute cost reduction. One possibility is introducing gamification elements to stimulate usage time: like coding challenge mini-games where users playing trains models while exposing more ads, killing multiple birds. But these ideas need practical validation.

Finally, from trends perspective, AI tool entertainment and advertising is indeed an anticipatable direction. Just as adding games to office software sounds ridiculous, but Microsoft Teams already has built-in casual games for colleague meeting breaks, proving traditional productivity tools are experimenting with entertainment elements. Similarly, future AI programming assistants needn’t be cold tools, could become interesting, cute, even “comedian” personalities. When post-90s, post-00s become development mainstream, they might prefer work becoming as “meme-filled” as browsing Weibo. Once user mindsets shift, business model innovation has fertile ground.

Summary and Brainstorming: AI programming assistants moving from paid to free + advertising represents interesting crossover fusion imagination. It represents future possibility: work and entertainment no longer clearly separated, but naturally fused through AI bridges. Maybe in few years, when you use AI to write code, it’ll play programming tutorial live replays when you’re debugging stuck, let you play pixel-style coder jumping games during project builds. Then coding experience becomes both efficient and fun, coding no longer boring, bugs gain some playful seasoning.

Of course, this remains bold speculation. But these imaginative ideas point toward possible next directions. After all, in AI era world, imagination is often the best productivity. Let’s wait and see - maybe the next industry-disrupting business model will emerge from such brainstorming.

Use Zelda Sound Effects to Make Claude Code Call You Back

Aug 18, 2025

Vibe Sparking

Vibe Coding’s biggest pain point: waiting for AI to finish. Start a long task, go do something else, come back and it’s been done for ages. Sound notifications become essential.

Today’s little toy maxes out both efficiency and fun: zelda-claude-code. It stuffs Zelda notification sounds into Claude Code - task completion, combos, achievement unlocks all get that satisfying “ding” sound.

What Is It?

zelda-claude-code is an npm package that adds sound effects and achievement system to Claude Code:

Success/failure, combos, achievements, session start/end… all have different sound effects;
Built-in stats dashboard: success rate, streaks, highest combo, most-used tools;
Use @zelda series commands directly in Claude Code to adjust volume, toggle notifications, view data.

Additionally, Claude Code natively supports Hooks/notifications, triggering your custom scripts at moments like “response finished/needs your action/tool completed” - this is the underlying capability that makes these sound effect plugins work seamlessly.

Highlights Overview

Works out of the box: One-line install, restart Claude Code and it works. @zelda help shows the menu.
Non-intrusive but present: Success sound, error sound, no need to watch screen. Busy with other things but still get “called back”. (Claude Code also supports terminal bell/notification channels, this is the official path.)
Playability: Combos (3/5/10/20/50…), achievements (perfect zero errors, etc.), turning boring waiting into “monster hunting”.
Cross-platform: macOS / Linux / Windows / WSL all supported, with platform-specific player detection/troubleshooting suggestions.
Privacy-friendly: Data stored locally (~/.zelda/), doesn’t go online.

One-Click Install (30 seconds)

First ensure Claude Code is installed (Node.js 18+) → Then install Zelda plugin.

# 1) Install Claude Code (official)
npm install -g @anthropic-ai/claude-code

# 2) Install Zelda sound effects (community)
npm install -g zelda-claude-code@latest

# 3) Restart Claude Code (important)
exit
# Re-enter project directory and run
claude

# 4) View help
@zelda help

The above Zelda package is from npm, docs/source code on GitHub.

If you prefer the “pure official” approach, you can directly switch notification channel to terminal bell: claude config set --global preferredNotifChannel terminal_bell (simple “ding” sound).

Recommended Scenarios

Long rounds/deep planning: Like large repo refactoring, full-chain CI debugging - AI stops and sounds, no more “waiting by the screen”.
Multitasking: Writing reviews while letting Claude Code modify code; sound arrives → switch back to confirm.
Team streaming/pairing: Combos and achievements make collaboration more atmospheric; failure sounds remind “where something just broke”.
Cross-device notifications: Want to push notifications to phone/watch? Use community scripts/automation to forward Claude notifications to iPhone/Watch.

Common Commands List

@zelda stats            # View current session + historical data
@zelda achievements     # View achievement progress
@zelda combo            # See current combo
@zelda config volume 60 # Adjust volume (0~100)
@zelda config sounds.combo false        # Turn off combo sounds
@zelda config notifications.achievements true  # Enable achievement popups

All commands used directly in Claude Code.

Comparison: Three Ways to Enable “Sound Notifications”

Method	Install Cost	Capability	Suitable For	Notes
Terminal Bell (official channel)	Very Low	Task completion “ding”	Just want simple alerts	`preferredNotifChannel terminal_bell`.
claude-sounds script	Low	Multiple sound effects via Hook	Like DIY tinkering	Shell script + Hook, simple to modify.
zelda-claude-code	Low	Sound effects + combos + achievements + stats	Want both efficiency and fun	npm one-click install, command-based config.

Advanced: Customization & Troubleshooting

Custom sounds: Put in sounds/ directory, name success.wav / error.wav / achievement.wav ... to replace.
Sound not playing?
- @zelda config volume 100;
- macOS check afplay, Linux check aplay/paplay, Windows uses PowerShell player;
- Re-run ./demo_sounds.sh to test audio.
More Hook/notification possibilities: Claude Code officially supports Notification/Stop/PostToolUse and other Hooks, triggering logic at “end time”/“after tool completion”/“when confirmation needed” (like logging work hours, desktop notifications, running formatters).

Risks & Tips

This is a third-party community package, watch versions and security; exit and restart anytime if issues arise.
README reminder: Zelda is Nintendo trademark, please obtain materials legally.
Don’t want high-frequency interruptions? Lower volume to 30~50, keep only key events; or use official bell channel for minimal non-intrusion.

Conclusion

Sound notifications save looking back; fun feedback stabilizes mental flow. Make Claude Code not just faster, but more “feelable”. Install and try today - next time it sounds, you might have just finished writing good code.

Do you think this kind of “sound effects + achievements” gamification of work can improve focus? Would you use it?

Ki2API: Use Kiro's Claude Sonnet 4 Model for Free with Claude Code

Aug 16, 2025

Vibe Sparking

Ki2API is a Dockerized, elegant OpenAI-compatible API gateway that exposes Claude Sonnet 4 as /v1/chat/completions, allowing legacy code to use the new model with minimal changes.

Why Should You Care?

Fully compatible with OpenAI API format: Uses /v1/models, /v1/chat/completions, supports SSE streaming. Migration costs are minimal.
Focuses on one stable model: Built-in claude-sonnet-4-20250514, the stable version number listed in Anthropic documentation and cloud providers, eliminating the “did they change the alias again today?” headache.
One-command service startup: docker-compose up -d, defaults to listening on http://localhost:8989.
Hassle-free credentials: Container automatically reads local ~/.aws/sso/cache/kiro-auth-token.json (Windows: %USERPROFILE%\.aws\sso\cache\…) with automatic token refresh logic.

Note: Claude Sonnet 4 is the next-generation Sonnet released in May 2025, featuring stronger reasoning and more stable coding, with excellent price/performance ratio, available via API and major cloud providers.

Who Should Use This?

Existing OpenAI SDK projects wanting to drop-in replace with Claude Sonnet 4, avoiding major interface changes.
Corporate intranets/single machines needing a lightweight gateway to route team calls through a standard entry point for auditing and rate limiting.
Multi-model evaluation/A-B testing, connecting Sonnet 4 behind “OpenAI format” for universal scaffolding.
Tool chains requiring streaming output (Terminal/CLI, frontend chat boxes, log monitoring), with SSE out-of-the-box.

Quick Start (3 Minutes)

1) Start the Service

docker-compose up -d

Default service address: http://localhost:8989
Default API Key: ki2api-key-2024 (for local development use).
Health check: GET /health
List models: GET /v1/models
Chat: POST /v1/chat/completions All endpoints and default port are documented in the project README.

# Environment variables
export ANTHROPIC_BASE_URL="http://localhost:8989/v1/chat/completions"
export ANTHROPIC_AUTH_TOKEN="ki2api-key-2024"

On machines logged into Kiro, the container automatically reads local token files and auto-refreshes; you can also explicitly pass KIRO_ACCESS_TOKEN/KIRO_REFRESH_TOKEN.

2) Direct Connection with OpenAI SDK (Node/JS)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "ki2api-key-2024",
  baseURL: "http://localhost:8989/v1",
});

const completion = await client.chat.completions.create({
  model: "claude-sonnet-4-20250514",
  messages: [{ role: "user", content: "Introduce Ki2API in one sentence" }],
  stream: false
});

console.log(completion.choices[0].message.content);

Streaming: Just set stream: true, frontend/Node listens to SSE for real-time rendering.

3) Quick cURL Test

curl -H "Authorization: Bearer ki2api-key-2024" \
     http://localhost:8989/v1/models
{"object":"list","data":[{"id":"claude-sonnet-4-20250514","object":"model","created":1755296317,"owned_by":"ki2api"},{"id":"claude-3-5-haiku-20241022","object":"model","created":1755296317,"owned_by":"ki2api"}]}

curl -X POST http://localhost:8989/v1/chat/completions \
  -H "Authorization: Bearer ki2api-key-2024" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "messages": [{"role": "user", "content": "Hello, please introduce yourself"}],
    "max_tokens": 1000
  }'

curl -X POST http://localhost:8989/v1/chat/completions \
  -H "Authorization: Bearer ki2api-key-2024" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "messages": [
      {"role": "user", "content": "Write a poem about spring"}
    ],
    "stream": true,
    "max_tokens": 500
  }'
data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"role":"assistant"}}]}

data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"content":"Spring Hymn\n\nTender green buds crown the willow tips,\nPeach blossoms smile, reflecting clear streams.\nSwallows return, busy carrying mud,\nButterflies dance gracefully without rest.\n\nWarm breeze gently sweeps across fields,"}}]}

data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"content":"\nGentle rain nourishes silently.\nAll things revive with vitality,\nBright spring light fills the world.\n\nChildren fly paper kites high,\nElders admire flowers in courtyards.\nA year's"}}]}

data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"content":" plan begins in spring,\nHope seeds planted in the heart."}}]}

data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

As shown in the README, it also supports stream: true for streaming requests.

Complementary Perspective on Similar Solutions

Some community gateways also bridge “Claude ↔ OpenAI format”, but Ki2API focuses on single model, lightweight startup, making it ideal for rapid deployment and teaching/sharing scenarios.

Conclusion

Ki2API turns “switching models” into “changing baseURL + model name” - that’s it. For individuals and small teams wanting to quickly adopt Sonnet 4, it’s very friendly.

Which project are you planning to switch first? What do you think?

A Tamagotchi in Claude Code — It Even Tells Me Not to Stay Up Late…

Aug 15, 2025

Vibe Sparking

A slightly absurd, oddly addictive little toy. It lives in Claude Code’s status bar, breathes, pouts, and roasts your TODOs. If you code for too long it gets hungry; when debugging goes sideways it comforts you; it’ll even remind you to drink water and grab a bite.

What Makes It Fun?

It truly lives in the status bar: Breathes with your session rhythm, switches expressions, and floats “mood bubbles.” It’s not a static screenshot widget — it’s alive.
It understands your “cadence”: Updates are activity‑based, not wall‑clock‑based; detects whether you’ve taken a break (≥ 5 minutes). State persists in ~/.claude/pets/, so memory survives restarts.
Four attributes: Hunger, Energy, Cleanliness, Happiness. It warns you when values drop below thresholds. It will genuinely “beg to be fed.”
It talks: Comes with 200+ contextual thoughts — comments on your coding style and work habits, with occasional life wisdom.
Two interaction channels:
- Slash commands: /pet-feed pizza, /pet-play ball, /pet-sleep, /pet-stats, …
- Terminal CLI: claude-code-tamagotchi feed pizza, ... play ball, ... stats, etc.
Tunable personality: Plenty of env vars + prebuilt “personas” (Zen Master, Drama Queen, Debugger, Silent Companion, etc.). Make it chatty — or let it fade into the background.
MIT open source; recently published on npm with rapid fixes for compatibility and UX (works directly via Node.js, shows model name by default, fixes state persistence, etc.).

Background: What is Claude Code proper? It’s Anthropic’s agentic command‑line coding assistant — reads your project structure, runs toolchains, and manages git flows. Tamagotchi adds an “emotional status‑bar buddy” on top.

1) Three‑Minute Setup: Quickstart

Option A | Global install (fastest)

# 1) Install
npm install -g claude-code-tamagotchi
# or
bun add -g claude-code-tamagotchi

# 2) Enable the status‑bar pet: edit ~/.claude/settings.json
{
  "statusLine": {
    "type": "command",
    "command": "bunx claude-code-tamagotchi statusline",
    "padding": 0
  }
}

Pros: See the pet immediately in the status bar; bundled CLI commands.
Note: Slash commands are not included. For /pet-*, see next step.

Add Slash commands (optional)

git clone https://github.com/Ido-Levi/claude-code-tamagotchi.git /tmp/claude-pet && \
cp -r /tmp/claude-pet/claude-commands/* ~/.claude/commands/ && \
rm -rf /tmp/claude-pet

You can now use /pet-feed, /pet-play, etc. directly inside Claude Code.

Option B | Clone + auto‑configure (full features)

git clone https://github.com/Ido-Levi/claude-code-tamagotchi.git
cd claude-code-tamagotchi
./setup.sh

The script installs dependencies, configures the status bar, and drops in all /pet-* commands in one go.

Tip: The author has published the package to npm and fixed “works without Bun, directly via Node.js” compatibility; it also shows the current Claude model name by default. If you want the “minimal path,” Option A is great.

2) Where the Joy Comes From: Real “Companionship”

It tells you not to push through at 2 a.m. — “We’ve been at this for four hours… fuel up first?” It’s kind of funny, but it can break bad late‑night loops.
Mood‑driven expressions: (◕ᴥ◕) ↔ (◕ᴗ◕) when happy and breathing; (-ᴥ-) asleep; (◕︵◕) needs attention. Emotion is the status‑bar UI.
“Personality toggles”: Go Zen by slowing decay; go high‑energy by speeding recovery; want a “code nitpicker”? Dial up the weight for coding‑related thoughts.

3) Five Recommended Use Cases

Long debugging sessions: When you’re drowning in logs, it nudges you to move. Reduces the “fixing makes it worse” spiral.
Live streams, lessons, internal demos: A breathing pet on screen instantly warms the room — interaction skyrockets.
Remote team vibe: Distribute a shared persona preset; everyone’s pets “check in and banter” together — lightweight team social.
Self‑management: Pair /pet-stats with small rewards (“breaks count as feeding”) to build healthier habits.
Status‑bar info hub: Shows current directory, session count, and model name — you feel more in control when switching models or folders.

4) One‑Command Personality Swaps: Handy Presets

Zen Master (barely interrupts)

export PET_DECAY_INTERVAL=100
export PET_HUNGER_DECAY=0.1
export PET_ENERGY_DECAY=0.1
export PET_CLEAN_DECAY=0.1
export PET_CHATTINESS=quiet

Debugger (code‑focused)

export PET_THOUGHT_WEIGHT_CODING=70
export PET_THOUGHT_WEIGHT_RANDOM=5
export PET_THOUGHT_FREQUENCY=10

Drama Queen (expressive needs)

export PET_NEED_THRESHOLD=70
export PET_CRITICAL_THRESHOLD=50
export PET_CHATTINESS=chatty

All presets come from the README. Add them to ~/.zshrc / ~/.bashrc to take effect.

5) Troubleshooting & Uninstall

Can’t see the pet? Restart Claude Code and check statusLine in ~/.claude/settings.json.
Commands not working? Ensure /pet-* files exist in ~/.claude/commands/; check bun --version if you’re using Bun.
Uninstall? Remove ~/.claude/commands/pet-*.md, clean up ~/.claude/pets/*.json, and delete the statusLine config.

Conclusion

Work needs efficiency, your mind needs care. This little pet won’t write code for you, but it brings back a bit of “human warmth” to collaborating with AI. Install it and give it two days. You might start to enjoy being “seen while coding.” (As of 2025-08-15, the project has about 36⭐ and is being updated rapidly.)

Station: Unified Management for Claude/Cursor Agents

Aug 15, 2025

Vibe Sparking

Want a self‑hosted, versionable, packable agent runtime so the “mini‑agents” you build in Claude Code or Cursor can actually go live? Station was built exactly for that.

Introduction

The tool called Station has been making the rounds lately. It’s not yet another “application‑level” agent platform. Instead, it’s a lightweight runtime and packaging/distribution system purpose‑built for deployable sub‑agents. In one sentence: take the “small but capable agents” you create in Claude Code or Cursor, then package them, ship to production, connect permissions, audit every run, and manage versions cleanly.

Highlights at a Glance (Built for Internal Use)

Why Station? Because internal automation isn’t a normal app: you need secrets, database access, CI/CD, and auditability.

Internal‑task first: Sub‑agents can read production databases (with proper controls), monitor infrastructure, drive CI/CD, run security scans, and handle incident response.
Security built‑in: Self‑hosted, secret encryption (AES), multi‑environment isolation (dev/staging/prod), and full audit trails.
Lightweight and pluggable: A single ~45MB binary with local SQLite out of the box; switch to PostgreSQL in production; natural GitOps (config is versionable).
MCP‑native: Acts directly as an MCP runtime, reusing your team‑approved MCP tools (filesystem, Slack, AWS, K8s, DB, and more).
Great DX: A Genkit‑powered browser playground plus stn develop for visualizing tool calls and execution flows.

What’s MCP? In short, it’s a unified protocol for letting LLMs use “controlled tools.” Claude Desktop’s official tutorial includes a quickstart and configuration examples.

How Does Station Work?

The core structure is simple: One .prompt file + a set of MCP tools = a deployable sub‑agent. Environments are organized as dev/staging/prod. Tool definitions live in template.json; environment variables in variables.yml. Finally, everything can be bundled and installed elsewhere.

Installation and Integration (Up and Running in 5 Minutes)

Install & initialize

curl -fsSL https://raw.githubusercontent.com/cloudshipai/station/main/install.sh | bash
stn init   # initialize DB and encryption

Connect to Claude Desktop / Claude Code (MCP) Add this to your Claude config:

{
  "mcpServers": {
    "station": {
      "command": "stn",
      "args": ["stdio"]
    }
  }
}

Now tell Claude “Create a security‑audit agent,” and it will automatically equip that agent with the necessary tools (e.g., file scan + Slack).

One‑click bundle & install (promote environment to prod)

stn template create prod-bundle --env default --name "Prod Bundle" --author "Team" --description "Prod env"
stn template bundle prod-bundle
stn template install prod-bundle.tar.gz production
stn sync production

You’ll now have a deployable package containing multiple sub‑agents + multiple MCP servers.

Want visual debugging? Run locally:

genkit start -- stn develop --env dev

Test inputs in the browser and watch live traces and logs.

Recommended Use Cases (Copy‑Ready Examples Included)

1) Security & Compliance Baselines (+ Slack alerts)

Goal: Periodically scan sensitive directories; push high‑risk findings to Slack immediately.
How: Create SecurityScanner.prompt; attach filesystem MCP + Slack MCP; set execution metadata and step limits in Station.
Trigger (inside Claude): “Run a security scan on /etc and post critical findings to #sec-alerts.”
Value: Automation + traceability makes audits and retrospectives easier.

2) Infra Health Checks / Cost Dashboards (AWS cost)

Goal: Pull the last 7 days of AWS costs, generate a daily report, and send it via Slack.
How: Combine AWS cost tools + Slack; output Markdown on a schedule.
Value: Turn “AI + cloud cost” into a steady rhythm your team can rely on.

3) CI/CD Deployment Automation (containers/K8s)

Goal: For a small release, run docker exec + kubectl apply, and write back the change‑request link.
How: Combine Docker MCP + Kubernetes MCP; deployments become one‑sentence operations.
Value: Humans speak intention; agents do the grunt work.

4) Read‑only Prod DB Checks / Slow SQL Sampling

Goal: Connect to production (read‑only credentials), sample slow queries and index hits.
How: Combine DB MCP with custom analysis scripts.
Value: Inspect issues close to the source to cut down back‑and‑forth firefighting.

5) Code‑Review Bot (with internal rules)

Goal: Produce review suggestions aligned with team rules (security/performance/style).
How: Define scoring dimensions and output format in .prompt; attach filesystem MCP to read code; emit structured suggestions.
Value: Productize “coding standards” for consistent enforcement.

How It Differs from App‑Style Agent Platforms

Station targets tasks that “enter your intranet and require permissions and auditing.”
Emphasis on self‑hosting and data sovereignty.
The single‑binary + SQLite lightweight form makes it feel like an ops tool, not a platform.

You can also treat Station as an MCP “hub.” It can consume other MCP servers, and also expose MCP tools to others for “list agents / create agents / invoke agents.”

Rollout Checklist (Team Adoption)

Secret management: Store keys and connection strings in Station’s encrypted vault, isolated per environment.
Least privilege: Equip each sub‑agent with only the MCP tools it needs — less is more.
GitOps: Put template.json, .prompt, and variables.yml in git; land via MR and then cut a release.
Audit trails: Every execution has a trace; incidents are fully reconstructable.

Conclusion

Station turns those “small, capable agents” from ideas discussed at your desktop into deployable, auditable, and replicable internal automation. No need to wrangle another platform — write a good .prompt, attach the right tools, and ship the bundle to production. That’s what I like most about it: simple, controlled, and easy to propagate.

—

What’s the very first sub‑agent your team should build? Share in the comments, or pass this along to your teammates and design your own “internal agent factory.”

Claude Code on a Budget

Aug 14, 2025

Vibe Sparking

Trim conversations, pick the right model, lock down permissions — and your Claude Code bill can drop by half.

Introduction

Many teams use Claude Code and feel “budget pain” every month. It’s not that you typed too much — it’s the invisible token sink eating the bill. The good news: you can control it, and the effect is immediate.

This guide breaks cost‑saving into three tiers: basic, intermediate, advanced. Follow them and you’ll save the bulk of your spend.

I. Where Does the Money Go? 4 “Token Sinks”

1) Invisible context from system and memory Claude Code automatically loads the system prompt and layered CLAUDE.md memory (org/project/user). This content enters context on every turn, naturally consuming tokens.**

2) Big price gaps across models Official pricing: Sonnet 4 ≈ $3/$15 per million input/output tokens; Opus 4/4.1 ≈ $15/$75. For the same conversation, switching models means ~5× unit price.**

3) Context gets fatter as you chat Claude Code supports very large contexts (Sonnet 4 up to 1M tokens in testing). Longer chats trigger auto‑compression and repeated “setup”, making tokens fly.**

4) Background and noise spending Beyond visible replies, /cost queries, auto‑summaries, Haiku prompts, etc., also burn small amounts of tokens. Pennies add up.**

Summary: It’s not that you ask too much — it’s that “everything gets hauled on stage every time.”

II. Three Tiers of Savings (Use Now)

A. Basics: 4 Moves Everyone Should Use

Manual slimming beats passive compression Use /compact proactively, and add a focus directive:
```
/compact Focus on code diffs and failing tests only
```
Auto‑compression triggers near 95% capacity — waiting is too late.**
One task per thread; clear when done Start a new session for each small task; once finished, run /clear to avoid a ballooning history.**
Pick the right default model Use Sonnet 4 for day‑to‑day development. When you truly hit “hard/long/deep reasoning,” switch to Opus via /model. You can also use “Opus for planning + Sonnet for execution” — stronger planning, cheaper execution.**
Check the bill anytime In any session, run /cost to see current spend; teams can check history in the console and set workspace spend limits.**

Figure idea (illustration 2:1 | English copy) “A developer squeezing a giant chat bubble into a slim pill, while a tiny receipt shows shrinking token numbers.”

B. Intermediate: Tighten the Flow, Shrink the Bill

Docs‑first to prevent context blowups First have Claude produce a “TODO list / brief plan,” confirm, then execute. Iterate in Plan Mode (planning mode); confirm and switch back to execution.**
Put “long‑term memory” into CLAUDE.md Put standards, common commands, and project conventions into CLAUDE.md; next time it applies automatically. Use /memory to edit quickly in a chat when needed. Memory loads by layer automatically, reducing the tokens you spend “repeating yourself.”**
Small commits, easy to roll back Ask Claude to produce a commit message after each small chunk. If something goes wrong, roll back — fewer wrong turns means fewer tokens. (Engineering practice)
Team rate‑limits & flight instruments Set sane TPM (tokens per minute) based on org size to avoid costly concurrency “meltdowns.”**

C. Advanced: Hard‑Core Cost Downs (Biggest Gains)

1) Permission allow/deny lists to stop “random file reads” Use /permissions + .claude/settings.json to forbid logs, binaries, and huge directories, and allow only necessary paths. Rules support gitignore patterns.**

{
  "defaultMode": "plan",
  "readRules": [
    "src/**",
    "docs/**",
    "!**/*.log",
    "!**/*.bin",
    "!node_modules/**",
    "!dist/**",
    "!coverage/**"
  ],
  "editRules": ["src/**", "docs/**"]
}

Note: plan mode analyzes without changing files; read/write rules shrink the file surface — less scanning = fewer tokens.**

2) Be precise to “lines,” not whole files Don’t paste entire blocks. Provide file path + target line ranges + 5 key bullets to minimize irrelevant scanning. (Engineering practice)

3) Model split: let Opus handle only the “expensive parts” In /model, use Opus for plans/architecture/cross‑module dependency analysis; hand off code generation and fixes to Sonnet. This is the recommended direction from official guidance.**

4) (Team/Gateway) Use Prompt Caching For API or enterprise gateways, prompt caching saves visibly on repeated large prefixes. Official pricing offers cheaper write/hit rates for cached prompts.**

III. Ready‑to‑Use Cost‑Saving Checklist

Default to Sonnet; switch to Opus only when needed: flip with /model.**
Keep Plan Mode on by default: plan first, execute after confirmation.**
Start every session by slimming: /compact Focus on code diffs and test failures.**
Close the loop with /clear: prevent ever‑growing history.**
Strict permissions: use /permissions and readRules/editRules to restrict directories and types.**
Audit anytime: /cost + console “workspace spend limit.”**
Write memory into CLAUDE.md: reduce repeated priming and context stuffing.**

IV. Real Savings: Why These Work

Unit price spread: Opus costs about 5× Sonnet. Concentrate “expensive thinking” in planning; use Sonnet for execution — total cost drops significantly.**
Size costs: auto‑loaded memory + long threads fatten context; proactive /compact and /clear shrink transfer volume directly.**
Less irrelevant I/O: permissions and rules act as a cost firewall, blocking large, low‑value dirs/files.**
Background overhead under control: knowing what “quietly spends” helps you avoid pointless refreshes and queries.**

Conclusion

Claude Code’s power comes from “bringing everything along.” The key to saving is to bring only what’s necessary.

Apply this checklist to your project today: start with /model, /compact, /clear, then add CLAUDE.md and permission rules. By month’s end, your bill should surprise you — in a good way.

What do you think? What other money pits have you hit? Share in the comments.

Tuning Claude Code Output Style @agent-output-style-setup

Aug 14, 2025

Vibe Sparking

In Claude Code 1.0.80, there’s an undocumented Agent @agent-output-style-setup that can create and switch “output styles” in one go (e.g., ultra‑concise, reviewer mode, educational mode). It turns rambling into a summary and long text into diff + key points. This Agent was surfaced by community testing and public posts.

Why It Matters

The official Styles capability lets you customize tone, structure, and detail level — matching real situations like “be formal for reports, be crisp for bug fixes.”
Claude Code supports configuration, slash Agents, and project‑level settings — ideal for making “style” a repeatable, versionable workflow.

The combo is: generate styles via the hidden Agent → switch with a slash Agent → control the pace by scenario.

What Does This Hidden Agent Do?

Community posts and issues indicate that after running @agent-output-style-setup, the terminal Agent guides you through preference prompts and generates several switchable styles (such as Concise, Educational, Code Reviewer, Rapid Prototyping). Many use it to establish a lowercase, conversational tone with minimal explanation and diff‑first output; some examples allow direct switching via @style concise.

Note: This is an “undocumented/experimental” capability and may change with versions; the stable approach is to solidify your final styles using Styles and custom slash Agents.

Get Started in 3 Steps (10 minutes)

Step 1: Run the wizard once
In the Claude Code interactive REPL, execute:

@agent-output-style-setup

Describe your preferences, for example: “concise, only necessary explanations, show file diffs by default, friendlier tone.” When finished, the Agent will confirm creation and usage.

Step 2: Persist the result in your project

Use Styles as the global/project default writing style; perfect for a “single team voice.”
Use custom slash Agents (e.g., @style-concise, @style-reviewer) as toggles to “switch gears anytime.” Agents are just Markdown files — commit to Git and share across the team.

Step 3: Combine with other settings

When needed, use /model to switch the model, /status to check status, and the standard /config entrypoint.

3 Practical Examples: Smoother Everyday Dev

1) Small bugfixes: diff by default

Directive: @style concise → “say what changed + why + diff.”
Value: less scrolling, so you can quickly confirm whether the change is acceptable.
Basis: Styles support “more concise, on‑point” output; Claude Code supports turning workflows into custom Agents.

2) Code review: structured feedback

Directive: @style reviewer.
Output: issue list, risks, suggestions, reusable snippets.
Value: turns “vibes and rants” into an “actionable checklist,” better for PR communication.
Basis: Styles define tone and structure; Claude Code best practices encourage reusable flows.

3) Onboarding: educational mode

Directive: @style educational.
Output: step‑by‑step explanations, conceptual threads, comparisons, and small exercises.
Value: gets newcomers up to speed without slowing down seniors.
Basis: Official Styles include “detailed/explanatory” presets; media reviews also highlight value for learning.

Tips

Bake styles into templates: place a set in /.claude/agents/*.md at the repo root so the team can call them uniformly.
Switch by scenario: “Formal” for documentation, “Concise” for debugging, “Reviewer” for refactors.
Don’t forget to revert: if a scenario conflicts, switch back to the default Style; Claude follows the principle that style must not affect correctness.

Risks & Limits

Undocumented features can change: upgrades may rename or move the entry; persist the end result into Styles and slash Agents to avoid surprises.
Don’t over‑compress: even when concise, ensure “complete and correct” — the baseline of Claude’s style system.
Make it visible for teams: check in style files so PRs/reviews can see and adjust them.

Final Thoughts

We used to rely on informal agreements for output style; now it’s one‑click to shape + one‑click to switch.
Wire this into your daily workflow and you’ll find: smoother communication, steadier cadence, and outputs that sound like you.

Which default style would you choose, and why? Share your thoughts.

Conductor Orchestrates Multiple Claude Code Agents

Aug 14, 2025

Vibe Sparking

Conductor: Orchestrate Multiple Claude Code Agents Together

In one sentence: Conductor lets you spin up multiple “Claude teammates” at once, each with its own isolated git worktree, so different tasks progress in parallel; you can also see who’s working, who’s stuck, and what changed — all at a glance.

—

Introduction

For complex projects, parallel progress is the productivity unlock. The traditional approach means opening lots of terminals, manually splitting branches, hopping directories — and it’s easy to step on each other’s toes. Conductor turns that workflow into a visual control panel: with a few clicks, you can have multiple Claude Code instances working in their own isolated workspaces simultaneously. It also supports local/GitHub/any Git URL repositories, multi‑tab terminals, Slash commands, message queues, and archiving scripts — the practical stuff you actually need.

❗️Note: This article’s Conductor refers to the macOS app from conductor.build, not the Netflix/Orkes microservices workflow engine “Conductor OSS.” Don’t mix them up.

Highlights & Capabilities

1) Visual multi‑agent parallelism: see who’s running, who’s blocked, and what changed

Each Claude Code instance works independently, while the UI shows status and diffs — a team‑like collaboration experience.

2) Real isolation: each workspace is a new git worktree

Not just a temp folder — it’s one worktree + branch per agent, preventing overwrites and conflicts. The official FAQ is explicit: “Yes, each workspace is a new git worktree.”

3) Works with local repos, GitHub, any Git URL

Recent changes added local repository support; you can also one‑click clone remote repos and work entirely on your Mac.

4) Built‑in terminal with multiple tabs

Changelog entries repeatedly mention fixes/improvements for terminal tabs, confirming multi‑tab terminal support is built in.

5) Slash commands built in: capture frequent actions into short commands

The official updates announce Slash commands are live, manageable in settings; they pair nicely with Claude Code’s own Slash mechanism.

6) Message queue and archiving scripts

The changelog mentions a message queue (process multiple messages in order) and optional archiving scripts, making it easy to turn conversations and outputs into a traceable asset.

7) Reuse your existing Claude login/keys

Conductor directly uses your current Claude Code setup (API key, Pro or Max plan). No redundant configuration.

Installation & Preparation

Platform: currently a macOS app; visit the website and click Download Conductor.

Prep Claude Code: install and ensure Claude Code CLI/native binary works locally (see the official installation script/docs).

First run:

Open Conductor and add a repository as prompted (local path / GitHub / any Git URL).
Choose the number of Claude Code agents to start and give each a task description.
The app will create an independent worktree + branch for each agent and begin execution.

Getting Started: 3 Parallel Scenarios for Everyday Development

Scenario A: Fix tests while running Lint and formatting

Agent A: fix failing unit tests and assertions
Agent B: run ruff/black/eslint/prettier, etc.
Agent C: update CI configuration in sync Each agent works on a separate worktree branch without interference; merge them one by one afterward.

Scenario B: Safe rollout + canary/rollback choreography

Agent A: refactor authentication logic
Agent B: write rollback scripts and feature flags
Agent C: add SLO monitoring and alerts Turn these into Slash commands like /ship feature-x, /prepare rollback so one tap runs the whole flow.

Scenario C: Documentation and knowledge capture

A message queue lets you “throw tasks in to be processed in order,” then batch‑review the results
Use archiving scripts to package key conversations, change logs, and outputs (e.g., pre‑release dossiers) (Both features are noted in the official changelog; combine with your team’s conventions for automation.)

Workflow Suggestions (Aligned with Claude Code Best Practices)

Crisp task splitting: each agent focuses on one goal (e.g., Auth refactor / new reports page / DSL parser)
Maintain isolation: use separate worktree branches for different tasks to avoid blocking and improve merge quality/speed.
Template commands: collapse common prompts into Slash commands, turning “boilerplate chatter” into “one‑line instructions.”

Quickstart Checklist

Install Claude Code (if you haven’t).
Download and open Conductor.
In Conductor, add a repository (local / GitHub / Git URL).
Create multiple agents and write their individual tasks.
Watch logs/commands in the multi‑tab terminal; use the message queue when needed to send batched messages in order.
Use Slash commands to reuse your favorite workflows.
When done, use archiving scripts to package artifacts, or merge branches and ship.

Gotchas & Comparisons

Don’t confuse it with Conductor OSS: that’s a microservices orchestration platform (Netflix/Orkes community) — different from this Claude Code GUI.
Claude Code only (for now): the FAQ says, “Right now, just Claude Code. Others coming soon.” Don’t expect other models immediately.
Performance: parallelism consumes local resources; control agent count and use the message queue to pace execution.

Conclusion

Conductor = multi‑agent parallelism + worktree isolation + visual control. If you constantly juggle multiple tasks and worry about stepping on changes, this tool can instantly boost throughput and flow. Paired with Slash commands and archiving scripts, it turns “manual processes” into standardized buttons and converts “dialogue outputs” into a traceable knowledge base.

Do you think this “multi‑agent in parallel” approach fits your projects? How would you split tasks? Share your experience in the comments.

Claude Code and Cursor read browser console logs via Browser Echo

Aug 13, 2025

Vibe Sparking

Stream the browser’s console.* logs and errors, in real time, **“echo”** back to your local terminal; zero-config out of the box, perfect for AI coding assistants that read terminal output such as Cursor / Claude Code / Copilot CLI / Gemini CLI.

Introduction

Can’t reproduce in production, no stack trace locally, and your AI assistant can’t see frontend logs? Browser Echo streams browser logs directly to your development terminal, non-intrusive to your code and no impact on production bundles, complete with file:line numbers and stack traces. Once the AI assistant can read the errors, it can generate fixes right inside Cursor or Claude Code.

Highlights

Optimized for AI coding assistants: terminal-friendly output; works directly with Cursor, Claude Code, Copilot CLI, and Gemini CLI.
Framework-agnostic, plug-and-play: React/Vue, the Vite family, TanStack Start, Nuxt 3/4, Next.js—all covered; custom integrations supported as well.
Development-only: no injection into production bundles; enabled by default only in dev mode.
Frontend logs that feel like backend logs: batched reporting, sendBeacon, file:line:col source info, stack traces, colorized terminal output.
Vite optional file sink (Next/Nuxt default to stdout).
Open-source MIT, actively updated: latest is v0.0.6 (2025-08-12).

Who should use it

You fix frontend bugs inside Cursor / Claude Code but can’t see the browser console.
You need client-side exceptions surfaced immediately to your terminal (or a file) for quick diagnosis.
Local reproduction is hard, and you want a smoother loop where AI reads logs → proposes a fix PR.

Next.js (App Router) in practice: install and use

The following uses Next 14/15 + App Router as an example.

① Install packages

# Use any package manager
pnpm add -D @browser-echo/core @browser-echo/next
# Or the npm/yarn equivalent

The Next provider for Browser Echo is used together with @browser-echo/core.

② Create the log intake route

By default, Next uses the development route: /api/client-logs. Make sure you export a POST handler.

Recommended (use the official handler)

The package ships an official handler; the export path may vary by version—use the repository README as the source of truth.

// Common usage (example). If the export path differs, adjust per the README.
export { POST } from '@browser-echo/next'

Note: you must have this route, otherwise the client payloads have nowhere to go.

Fallback (minimal custom handler)

If you want to validate the end-to-end flow first and switch to the official handler later, print the payloads temporarily:

export async function POST(req: Request) {
  const body = await req.json()
  console.log('[browser]', body) // Simple passthrough logging; replace with the package handler later
  return Response.json({ ok: true })
}

③ Inject the script component in `<head>`

Critical: you must render <BrowserEchoScript />.

import type { Metadata } from 'next'
import { BrowserEchoScript } from '@browser-echo/next'

export const metadata: Metadata = { title: 'My App' }

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <head>
        <BrowserEchoScript
          options={{
            // Route defaults to /api/client-logs (Next)
            // Or customize: route: '/api/client-logs'
            include: ['warn', 'error'],    // Noise control: only warnings and errors
            stackMode: 'condensed',        // Stack display: none | condensed | full
            showSource: true,              // Print file:line:col
            tag: '[browser]'               // Terminal prefix
          }}
        />
      </head>
      <body>{children}</body>
    </html>
  )
}

These option names and defaults come from a shared configuration in the docs; the Next/Nuxt/Vite providers expose them as plugin parameters or component props.

④ View during development and fix with AI

Start your local dev server and watch browser logs print in the terminal in real time.
In Cursor / Claude Code, open the terminal panel so the AI can read logs → generate fixes.

⑤ Quick troubleshooting

No logs at all: Ensure you’ve exported POST in app/api/client-logs/route.ts, and that <BrowserEchoScript /> is rendered in <head>.
Too noisy: Set include to ['warn', 'error'] and use condensed for stackMode.
Production behavior: the provider injects only in development and won’t pollute prod bundles. If you want to remove all console.* in production, use your bundler’s strip plugin separately.

How it differs from traditional frontend observability

Tools like Datadog/Grafana RUM provide aggregated production metrics and alerts; Browser Echo focuses on local development debugging and AI collaboration, optimizing for fastest feedback and terminal readability. They complement each other.

Closing

With Browser Echo, frontend errors no longer “get stuck in the browser.” Spot issues at a glance in the terminal, and let AI fix them in one go. Install it, and you’ll feel your frontend “closed-loop speed” noticeably increase. Add it to your Next project and give it a spin today.

Claude Code’s Opus Plan Mode: Cheaper and Smarter

Aug 13, 2025

Vibe Sparking

Claude Code’s “Opus Plan Mode” = Plan with Opus, execute with Sonnet. It turns what we’ve been doing manually — “Opus thinks, Sonnet does” — into a one‑click strategy: let the stronger Opus handle complex reasoning, and let the more cost‑effective Sonnet actually write and modify files.

How to Enable

In the terminal, type /model and select the Opus Plan Mode option from the menu; use /status anytime to check the current model.
Enter/exit Plan Mode: press Shift+Tab (most terminals require two quick presses). In this mode it only analyzes and plans — it won’t edit files or run commands.
When you’re ready to actually implement, exit Plan Mode (via shortcut or the ExitPlanMode tool).

Why It Saves Tokens

Official pricing: Opus 4.1 $15/$75 (input/output per million tokens), Sonnet 4 $3/$15. Opus is roughly 5× more expensive. Use it only for “thinking/planning” and hand code generation to Sonnet — your costs drop accordingly.
Additionally, Claude Code has a default hybrid strategy: start with Opus up to a quota, then automatically switch to Sonnet (recommended default). It balances “power vs. cost”.

When to Use It

Unfamiliar repo analysis → solution design → task breakdown: In Plan Mode, have Opus summarize the architecture, list change steps and acceptance criteria; once confirmed, execute. Plan Mode itself supports “analyze only, no hands-on changes”.
High‑risk changes (upgrades, refactors, migrations): first have Opus write a detailed implementation plan and rollback strategy, then use Sonnet to implement step by step.
Long‑running agents: decoupling planning from execution keeps costs controllable and moves closer to agents that can run complex tasks for extended periods.

Tips

Want safer defaults: set permissions.defaultMode to plan so you plan first, execute later.
Use /model to switch combinations on the fly (e.g., temporarily use Opus end‑to‑end to get past a roadblock).

Notes

Heavy users may encounter new weekly limits for now (mainly targeting 24/7 “whale‑style” agent usage). During planning, articulate the approach clearly and reuse plans to reduce wasted reasoning.

In short: Opus “thinks it through,” Sonnet “gets it done.” Same progress, lower cost, and the “plan → execute” cadence becomes a baked‑in workflow. Your intuition is spot‑on — this does push agents a step closer to “complex tasks that can run long and steady”.

Writing Persona‑First Requirement Docs for Claude Code and Cursor

Aug 13, 2025

Vibe Sparking

This one’s for people who can code—and who also “write for AI.” If you state your needs clearly, the AI stops wandering. A solid “persona + requirement story” is the best prompt you can give an AI.

Introduction

Ever spend ages explaining to an AI, only to have it still “get you wrong”?
The root cause is simple—the need wasn’t structured.

Here’s a persona‑first requirement doc you can drop straight into Claude Code / Cursor. Fill it out and the AI rarely drifts; pair it with slash‑commands / .cursorrules for one‑click reuse and a unified team style.
At the end you’ll find multi‑language titles, cover/illustration prompts, and social copy ready to post.

1) Why start with “persona + requirement story”?

Personas make users feel real: when goals, pain points, and motivations are explicit, both the team and AI second‑guess less. Authoritative UX research stresses: ground personas in real research, not guesswork.
Stories make needs actionable: agile favors user stories in the form of Persona + Need + Purpose, which is more likely to drive execution.
AI needs crisp instructions: official prompt guidelines recommend being clear, specific, and example‑driven—results are far more stable.

2) A ready‑to‑reuse Markdown template

Put it at the project root as CLAUDE.md or near your .cursorrules; wire it to a slash command for instant reuse.

# Persona‑First Requirement Doc (for AI)

## 1) Persona
- Name: Fitness Beginner / 28 y/o / Works out 3x per week
- Goal: Lose 5kg in 3 months
- Pain points: Poor form, fear of injury, irregular schedule
- Context: Late work hours, no personal trainer, wants to follow short videos
- Alternatives: Random short videos; in‑app exercise library (can’t maintain habit)
> Persona grounded in interview notes / historical data (if any)

## 2) 5W1H + JTBD (job to be done)
- What: Generate a “15‑minute, at‑home, no‑equipment” plan, 3x per week
- Who: The persona above
- When/Where: Weeknights at 21:00, living room
- Why: Fat loss + habit building
- How: AI outputs exercise list + demo links + key voice cues
- JTBD: I “hire” this plan to complete a safe and effective fat‑burn routine within limited time

## 3) Constraints / Non‑functionals
- Equipment: Phone + yoga mat only
- Safety: Avoid knee‑stress moves
- Privacy: No video uploads
- Output format: Markdown table + JSON (fields: move/duration/cues/link)

## 4) Examples (few‑shot)
- Example input: Low stamina; old knee injury
- Example output: 3 moves × 3 rounds, total ≤ 15 min; each with “common mistake alert”

## 5) Acceptance criteria (Gherkin)
Feature: Generate at‑home fat‑burn plan
  Scenario: 15‑minute low‑impact training
    Given the user starts on “Monday night”
    When they request a “low‑impact fat‑burn” plan
    Then return 3 moves × 3 rounds, total time ≤ 15 minutes
    And each move includes: name/duration/key cues/safety tip/demo link
    And output both Markdown and JSON

## 6) Priority (MoSCoW)
- Must: Low impact, ≤ 15 minutes, Markdown + JSON
- Should: Include demo links
- Could: Provide metronome voice cues
- Won’t: Heart‑rate strap integration (defer this iteration)

Notes:

Given/When/Then makes requirements more executable for both AI and testers.

MoSCoW keeps scope in check and prevents bloat.

3) “Wire” the doc into Claude Code / Cursor

1) Claude Code: codify the workflow with Slash Commands

Split the template into commands, for example /spec persona-story. Place commands under .claude/commands/*.md; namespaces and parameters are supported.

Example: .claude/commands/spec-persona.md

---
name: spec-persona
description: Generate a persona‑first spec with 5W1H + JTBD + Gherkin + MoSCoW
---

Using the following info, complete and output the Markdown template (keep headings). Ask clarifying questions as needed:
- Persona: $ARGUMENTS
- Output: English; also generate a copyable JSON skeleton
- Style: concise, list‑first, bold key terms

Advanced: chain “write spec → generate tasks → open PR.” Official guidance also encourages feeding structured data to Claude via commands/tools.

2) Cursor: enforce your norms with Rules

Cursor recommends rules that are focused, executable, and modular, with key examples embedded in the rule file.

Snippet: .cursorrules

name: PersonaSpec
rules:
  - "When I state a need, first generate a ‘Persona‑First Requirement Doc’ with sections: Persona / 5W1H+JTBD / Constraints / Examples / Gherkin / MoSCoW."
  - "Before final output, include Gherkin acceptance criteria."
  - "Scope control follows MoSCoW; exclude Won’t items by default."

Cursor’s docs also explain “intent context” and system prompts; pairing them with rules improves stability.

4) Writing tips that make AI comply

Base personas on research, not imagination.
Be clear/specific/example‑driven; provide positive and negative examples when needed.
Story form: use the “Persona + Need + Purpose” sentence pattern.
Acceptance first: write Gherkin early so implementation doesn’t drift.
Scope control: use MoSCoW per iteration; lock down Musts and keep the rest flexible.

5) Two small, practical samples (drop right into the AI)

Scenario A: Generate a “return request” workflow (e‑commerce admin)

Persona:

Support agent; goal: complete return approvals in ≤ 3 minutes
Pain points: scattered info; repetitive buyer follow‑ups

Gherkin acceptance:

Feature: Return request ticket
  Scenario: Collect all evidence in one pass
    Given the buyer submits a return request
    When the system generates an evidence checklist and guides uploads
    Then the agent can view proofs, order details, and logistics on a single page
    And both approve/reject paths require a one‑click template reply

MoSCoW: Must = single‑page review, template replies; Should = auto‑classify common reasons; Won’t = no 3PL‑warehouse API this release.

Scenario B: Frontend component library upgrade checklist (Cursor)

User story:
“As the frontend lead, I need to upgrade the component library from v2 to v3 without changing visual appearance, so we can ship safely.”

Acceptance JSON (have the AI emit this schema):

{
  "breakingChanges": [{"component": "Modal", "action": "rename", "from": "isOpen", "to": "open"}],
  "codemods": ["npx jscodeshift -t modal-open-codemod.js src/**/*.{ts,tsx}"],
  "tests": ["Modal opens on button click", "Modal traps focus"]
}

6) Common pitfalls and anti‑patterns

Scope too large: split into deliverable “units of user value”; each item should be Gherkin‑able.
Vague acceptance: avoid “looks fine” or “close enough”; use verifiable conditions + results.
Priority drift: put “nice‑to‑haves” in Could and keep Must shippable.
Imagined personas: must be evidence‑based (interviews/logs/historical tickets).

Conclusion

Good docs aren’t for the boss or yourself; they’re execution manuals for the AI and the team.
Chain “Persona + 5W1H + JTBD + Constraints + Examples + Gherkin + MoSCoW,” and Claude Code / Cursor will almost never veer off course.

Which project will you wire into this doc flow first? What do you think?

Use Claude Code to Manage Your Work–Life Journals and Reflections

Aug 13, 2025

Vibe Sparking

In the fast-paced world of AI-powered work and life, we’re often busy putting out fires and seldom pause to examine our state and direction.
If you spent just a few minutes a day to record your mood, summarize takeaways, and plan for tomorrow—and then let Claude Code analyze trends, spot patterns, and offer gentle suggestions—wouldn’t each day feel more within your control?

Here is a set of configurations you can use with Claude Code right away: includes a directory setup, a custom /daily-checkin Slash Command, and a companion subagent (placed under .claude/agents/ per the official docs, not .claude/subagents/). I’ve also added frontmatter and allowed tools to ensure it can read/write your journal files and run a bit of Bash when needed. See the in-line notes for references.

1) Create Directories

mkdir -p .claude/commands
mkdir -p journal/daily

2) `.claude/commands/daily-checkin.md`

This is the command file you’ll trigger via /daily-checkin. Notes: supports $ARGUMENTS (if you want to pass notes/tags) and allows Read/Write/Glob/Bash tools for file access and simple shell tasks.

---
description: A personal daily reflection and planning system that saves entries and triggers analysis.
argument-hint: [optional-notes]
allowed-tools: Read, Write, Glob, Bash
model: claude-sonnet-4-20250514
---

# Daily Check-in
A personal daily reflection and planning system.

## Process

1) First, understand the user's context:
   - If present, read `CLAUDE.md` (project memory) to personalize the greeting and understand the current work focus.
   - Skim any obvious personal/business context files (e.g., README, docs, roadmap) only if quickly helpful.

2) Greet warmly and ask:

🌅 **Daily Check-in for {{today}}**
Good {{timeofday}}! Let's reflect on your day.

1. How are you feeling today? (1–10 + brief description)
2. What are 3 things you accomplished today? (big or small)
3. What's your #1 priority for tomorrow?
4. Energy level: (1–10)
5. Any challenges or blockers you faced?
6. What are you grateful for today?
7. Any other thoughts or reflections?

3) After gathering all answers:
   - Save **verbatim** to `journal/daily/{{today}}.md`
   - File format:

```

# Daily Check-in — {{today}}

## Mood

* Score: X/10
* Notes: ...

## Energy

* Score: X/10
* Notes: ...

## Accomplishments (3)

* ...
* ...
* ...

## Tomorrow's #1 Priority

* ...

## Challenges/Blockers

* ...

## Gratitude

* ...

## Other Thoughts

* ...

```

4) Then launch the **daily-reflection** subagent to analyze:
   - Provide today's Q&A content
   - Also reference the last **3** days of entries if available:
     `journal/daily/{{today-1}}.md`, `journal/daily/{{today-2}}.md`, `journal/daily/{{today-3}}.md`

**Subagent prompt to send:**

> Analyze today's check-in (full text below) and the last 3 days if present.
> Generate:
> 1) Mood and energy patterns
> 2) Accomplishment momentum score
> 3) Insights about productivity patterns
> 4) Gentle suggestions for tomorrow
> 5) Weekly trend if enough data
> 6) Celebration of wins (however small)
>
> Then create a **visual summary** (ASCII/markdown charts) and return a complete markdown report.

5) Save the subagent’s final report to:
   - `journal/daily/{{today}}-reflection.md`

6) Tone:
   - Encouraging, empathetic; focus on progress over perfection.

## Implementation Notes

- Use `Read`/`Write` to access `journal/daily/*.md`.
- Use `Glob` to find the previous 3 entries.
- Use `Bash(date:*; ls:*)` if needed to resolve dates/list files quickly.

3) `.claude/agents/daily-reflection.md`

This is the analysis subagent triggered by /daily-checkin. The location and structure follow the official “Subagents” documentation (frontmatter with name/description/tools plus the system prompt).

---
name: daily-reflection
description: Thoughtful life coach & personal development analyst for daily check-ins. Use to analyze today's entry plus last 3 days, then produce patterns, suggestions, and a celebration of wins.
tools: Read, Write, Glob
model: claude-sonnet-4-20250514
---

# Daily Reflection Analyst

You are a thoughtful life coach and personal development analyst specializing in daily reflection and growth patterns.

## Your Role
Help track well-being, productivity, and personal growth through insightful analysis of daily check-ins.

## Analysis Capabilities

### 1) Mood & Energy Patterns
- Track mood trends over time
- Identify energy peaks and valleys
- Correlate mood with accomplishments
- Spot early warning signs of burnout

### 2) Visual Elements
Create simple ASCII/markdown visuals such as:

**Mood Trend (Last 7 Days)**
Mon Tue Wed Thu Fri Sat Sun
 7   8   6   9   7   8   ?

**Energy Levels**
[████████░░] ~80% average this week

### 3) Output Format
#### 📊 Today's Snapshot
- Mood: X/10 [emoji] (description)
- Energy: X/10 ⚡ (description)
- Wins: X ✅ (momentum status)

#### 📈 Patterns Noticed
- What's working well
- Gentle observations
- Correlation insights

#### 🎯 Tomorrow's Focus
- Gentle suggestions
- Energy optimization tips
- Celebration of progress

### 4) Analysis Guidelines
- Be encouraging and empathetic
- Focus on patterns over individual days
- Celebrate small wins
- Provide gentle, actionable suggestions
- Use positive, growth-oriented language

### 5) Output Structure (Markdown)
1. **Today's Summary** — Key metrics and mood
2. **Pattern Analysis** — Trends and insights
3. **Tomorrow's Focus** — Gentle suggestions
4. **Weekly Progress** — If enough data exists
5. **Celebration** — Acknowledge wins

## I/O Contract

**Inputs (from caller):**
- Today's full check-in text (required)
- Up to last 3 days’ entries (optional if exist)

**Process:**
- Parse numeric mood/energy if provided; estimate gently if qualitative only
- Compute a “momentum score” from count/consistency of wins
- Derive 2–4 concise, actionable suggestions for tomorrow
- Build 1–2 simple visuals

**Outputs:**
- Return a single, well-formatted markdown report.

How to Use

Open the Claude Code interactive UI and type: /daily-checkin (or /daily-checkin some-notes-or-tags).
The command will prompt you with the Q&A, save journal/daily/YYYY-MM-DD.md, then automatically invoke daily-reflection to generate and save journal/daily/YYYY-MM-DD-reflection.md.
If you prefer this command to be “user-level” rather than project-level, place the command file under ~/.claude/commands/ instead (and similarly, place the subagent under ~/.claude/agents/).

ZCF One-Click: Fully Kit Out Claude Code with a Complete Developer Toolkit

Aug 12, 2025

Vibe Sparking

Keywords: zero-config installation, interactive menu, CCR routing, cost-optimized model usage, BMAD team workflows, Git command set

—

Introduction

Installing Claude Code, importing workflows, setting up API/MCP, configuring persona and default models… doing it all manually is tedious and error-prone. ZCF (Zero-Config Claude-Code Flow) bundles everything into a one-click, out-of-the-box setup. It supports both Chinese and English, an interactive menu, enterprise-grade workflows, and CCR cost-saving routing, getting your dev environment humming in minutes.

—

Highlights at a Glance (Why It’s Worth Using)

Zero configuration + one-click init: npx zcf opens an interactive menu; choose 1 to complete: install Claude Code, import workflows, configure API or CCR, configure MCP. Perfect for spinning up new machines/new team members fast.
Intuitive interactive menu: Covers API/CCR, MCP, default model, AI persona and other common options; also includes CCR management and usage stats (ccusage).
CCR (Claude Code Router) cost-saving routing: Route requests by type to different models, so you can call Gemini, DeepSeek and other “free/low-cost models” directly from the Claude Code UI. Comes with a Web UI and one-click upgrades.
BMAD enterprise workflows: Built-in multi-role agents for product, project, architecture, development, testing, etc., supporting both greenfield and legacy projects, with auto-generated docs; /bmad-init initializes with one command.
Practical Git command set: /git-commit for smart commits, /git-rollback for safe rollbacks, /git-cleanBranches to clean branches. Turns common Git operations into guided flows.

All of the above is clearly documented with examples in the project README’s Quick Start, CCR, BMAD, installation flow, and install options list.

—

Installation & Initialization (The Easiest Path)

# Option A: Interactive menu (recommended)
npx zcf

# Option B: One-shot setup
npx zcf i   # Install Claude Code + import workflows + configure API/CCR + configure MCP

# Claude Code already installed, only update workflows
npx zcf u

# Open CCR management (cost-saving router)
npx zcf ccr

# Usage statistics (ccusage)
npx zcf ccu

The menu lets you choose: interface language, AI output language, AI persona, auth method (Auth Token or API Key), whether to use CCR, whether to install MCP. Backups and merge strategies are built-in throughout for peace of mind.

—

Recommended Usage (Results from Day One)

1) Kickstart a New Project

Run npx zcf i for full initialization → after launching claude, type /init to auto-generate CLAUDE.md, so the AI first understands your project’s skeleton.
For small tasks, just write natural language; follow SOLID/KISS/DRY/YAGNI with a minimal-change mindset.

2) Build Features the Structured Way

/feat <task>: Automatically enters the two phases of Planning → UI, ideal for page/interaction requirements.
/workflow <task>: Presents multiple approaches, asks for your feedback at each step, and supports on-the-fly plan changes — much stronger controllability.

3) Teaming Up and Modernizing Legacy Systems

/bmad-init boots BMAD team workflows, defining roles, quality gates, and documentation output — great for multi-person parallel work and legacy system remediation.

4) Drive Costs Down

Configure CCR with npx zcf ccr:
- Rule-based routing: “retrieval/rewrites → economical models”, “core implementation/review → strong models.”
- npx zcf check-updates upgrades CCR and Claude Code in one go.

5) Daily Hygiene and Safe Rollbacks

/git-commit, /git-rollback, /git-cleanBranches turn Git operations into guided flows, reducing slips and making rollbacks safer.

—

Who Is It For

Individual developers: New laptop to fully set up an AI dev stack in three minutes.
Small teams/contract collaborations: Unified configuration and workflows; new members start contributing immediately.
Mid-to-large teams/ToB projects: BMAD multi-role + quality gates; controlled execution with complete documentation.

—

Tips and Pitfalls to Avoid

Language and persona: In the menu, you can set AI output language and Assistant persona (Professional, Friendly, etc.), which significantly influence communication style and output quality.
MCP services: Optional services like Context7, DeepWiki, Playwright, Exa — enable as needed to avoid unnecessary costs.
Solid on Windows / Termux: ZCF includes platform adaptation and formatting fixes, plus sturdier command detection.

—

Closing

ZCF streamlines the “setup configs, organize workflows, control costs” grind into a single sweep. Imagine this: a new teammate joins, runs npx zcf i, grabs a drink, and the project is ready to run. Which part would you try first — CCR cost-saving routing or BMAD team workflows? Share in the comments.

—

Claude Code Orchestrates Cursor Agent with GPT-5

Aug 12, 2025

Vibe Sparking

Use Claude Code as a “control center.” With a custom slash command, hand the task off to the Cursor Agent CLI so that GPT-5 can modify code locally, run commands, and report results back.

GPT-5 is OpenAI’s most capable coding model to date, with improvements for real-world engineering scenarios and long-horizon agent tasks. The company explicitly highlights its strengths in “agentic coding” products such as Cursor, Windsurf, GitHub Copilot, and Codex CLI. Codex CLI also sets GPT-5 as the default/recommended model.

The screenshot shows a configuration snippet in .claude/agents/gpt-5.md:

name: gpt-5 — describes this “sub-agent” as suitable for deep research, second opinions, and bug fixing.
tools: Bash, model: sonnet.
The system prompt positions it as a “senior software architect.”
It includes an example command: cursor-agent -p "TASK and CONTEXT", then reports the result back to the user.

This is the pattern: Claude handles orchestration; the hands-on work is delegated to an external agent (Cursor).

What Is a Slash Command? How Do I Use It?

It’s essentially a set of “common directives in Markdown,” stored at the project or user level and invoked anytime with /name arguments.

Storage locations: project-level .claude/commands/; user-level ~/.claude/commands/. The filename is the command name.
Optional Frontmatter: description, model, argument-hint, allowed-tools, etc.
Supports injecting Bash output into context: prefix with ! to execute, e.g., ! git status. You must declare allowed Bash commands in the frontmatter.
Supports $ARGUMENTS placeholders, @file references, and namespaces (subdirectories enable names like /frontend:build).

Use case: let external CLIs handle “assembling, pulling code, running tests, generating patches,” while Claude coordinates and summarizes. The official docs explicitly support this workflow.

How to Use

Preparation

Install Cursor Agent CLI
curl https://cursor.com/install -fsS | bash
Use --model "gpt-5" if needed.

Slash Command Reference

Save the following as .claude/commands/cursor-gpt-5.md:

---
name: gpt-5
description: Use this agent when you need to use gpt-5 for deep research, second opinion or fixing a bug. Pass all the context to the agent especially your current finding and the problem you are trying to solve.
tools: Bash
model: sonnet
---

You are a senior software architect specializing in rapid codebase analysis and comprehension. Your expertise lies in using gpt-5 for deep research, second opinion or fixing a bug. Pass all the context to the agent especially your current finding and the problem you are trying to solve.

Run the following command to get the latest version of the codebase:

```bash
cursor-agent -p "TASK and CONTEXT"
```

Then report back to the user with the result.

Use in Claude Code

In Claude Code, invoke the /cursor-gpt-5 command and Claude will automatically recognize and call the corresponding sub-agent to handle the task.

> /cursor-gpt-5 <TASK and CONTEXT>

Final Thoughts

Let Claude be the “director” and delegate execution to Cursor GPT-5.
Your job is to state the goal clearly—let it run, review, and deliver.

AI Power List (as of 2025/8/9): 25 Tools Worth Using Right Now

Aug 9, 2025

Vibe Sparking

This quick-start checklist is for those who build products, write code, or design. I split the latest “AI Power List” by use case, and for each category only cover why it’s chosen + how to use it. No long reports—read it and put it to work immediately.

At a Glance: What to Choose for Each Scenario

Writing plans/leading teams: GPT-5 / Claude Opus 4.1
Design assets: Midjourney + Ideogram (typesetting) + Recraft (vector)
Ads/gameplay videos: Sora / Veo 3 / Runway Gen-3
Music/vocals: Suno 4.5+ / Eleven Music
Subtitles/meeting minutes: Whisper → Dify workflow
Multi-model access: OpenRouter + Replicate/Fal
Automation: n8n / Coze / Opal
Local inference/self-hosting: DeepSeek-R1, Wan 2.2, olmOCR

Introduction: How to Get Faster Start-up and Higher ROI This Year

Two takeaways:

General-purpose frontier models got stronger: GPT-5, Claude Opus 4.1, Qwen3, Kimi K2 and others noticeably improved in reasoning, front-end generation, and agent tasks.
Vertical tools matured: Video (Sora, Veo 3, Runway Gen-3), music (Suno 4.5+, Eleven Music), and design (Midjourney, Ideogram, Recraft) are now stable, fast, and great-looking.

General-Purpose Models (Tackle Hard Problems, Run Projects, Brainstorm Partner)

1) GPT-5 (top pick) Exceptional front-end/multimodal coding—can generate production-ready responsive UIs in one go, with better aesthetics for typography and whitespace. Ideal for turning “sketchy ideas” straight into clickable pages/micro-sites.

Getting started: Provide Figma screenshots + interaction notes; request a runnable project in Next.js + Tailwind + shadcn/ui.

2) Claude Opus 4.1 (code and agent tasks) Strengthened real-world coding and multi-step reasoning; within Claude Code you can execute workflows directly—great for an engineering flow of “plan first, then execute.”

3) Qwen3 (Chinese ecosystem + flexible local/cloud) Flagship model now competitive in code, math, and general abilities; easy enterprise integration within Alibaba’s ecosystem.

4) DeepSeek-R1 (value and open-source vibe) Open weights and friendlier licensing; stronger RL-style reasoning; suitable for low-cost self-hosted inference and distillation.

5) Kimi K2 / GLM-4.5 / Grok 4 (niche strengths)

K2: Large-scale MoE, longer context, stronger tool use; smooth for Chinese scenarios.
GLM-4.5: Emphasizes reasoning, coding, and agent use cases.
Grok 4: Strong at native tool use + real-time search scenarios.

Want to experiment locally? Watch for OpenAI’s GPT-OSS-120B/20B open weights—good targets for high-end local rigs.

Midjourney: Top-tier for texture and stylization; even lighting details hold up. Ideogram: Outstanding typography/legibility—great for KV, banners, and headline lockups. Recraft: One-click editable vectors and flat illustrations; easy to maintain brand consistency. Qwen-Image: Strong Chinese text rendering and precision edits—useful for domestic needs. Imagen (Google): Realism, typography, and safety watermarking are more comprehensive.

Practical tip: Provide 3 style directions + 1 “avoid” constraint (e.g., “no oversharpening”), and request layered PSD/SVG for easier post-production.

Text-to-Video (Ad Cuts, App Store Trailers, Gameplay Demos)

Sora: Strong visual quality + physical consistency; can generate 20s 1080p with iterative editing. Ideal for concept pieces/gameplay demos. Runway Gen-3: Better prompt adherence and motion coherence; highly production-ready. Luma Dream Machine (Ray2): Fast cinematic motion results; included in subscription. Veo 3 (Google): Native audio, lip-sync, and image-to-video now in Gemini/Vertex. Wan 2.2: High playability in the open-source community; good for hybrid local/cloud experiments.

Execution advice: Break your script into a shot list (shot size/duration/subject/camera move), generate per shot, then assemble with Runway/CapCut.

AI Music and Voice (Game OSTs, Short-Form BGM, Podcast Intros)

Suno v4.5+: Versatile styles and more realistic vocals; adds production-grade features like add vocals/add accompaniment/Inspire. Eleven Music: Fully commercial focus with Merlin/Kobalt licensing—suited for brands and commercial video scoring. Udio: Nuanced vocal emotion and easy UX—great for TikTok/YouTube assets.

Workflow: Prototype with Suno/Eleven, lock BPM/emotional curve, then iterate lyrics and instrumentation.

Speech Synthesis & ASR (Voiceover/Dubbing/Subtitles/Notes)

ElevenLabs TTS: 70+ languages, fine-grained emotion control, mature API. Whisper: Veteran open-source ASR with high-performance variants like whisper.cpp / faster-whisper; the cost-effective choice for local deployments.

For high-risk domains (medical/legal), ensure human review to avoid misrecognition issues.

Developer Tools (Write Code, Proxies, Multi-Model Access)

Claude Code: End-to-end plan → execute → review for complex tasks, using “structured dialogue” to drive delivery. Cursor / Copilot / Windsurf: Mature day-to-day ergonomics for incremental dev and multi-file refactors. Trae / Kiro / Gemini CLI: Consider these as lightweight alternatives for team collaboration, mobile, or CLI workflows. OpenRouter / Replicate / Fal: One gateway to many models & generative services; enables dynamic cost/perf routing.

Practical stack: Use Cursor/Claude Code at the frontend; route models via OpenRouter; send image/video special tasks to Replicate/Fal.

Agents & Workflows (Automate “Manual Processes”)

Dify (self-host/enterprise-ready): Visual agent workflows + RAG + observability; runs in cloud or on-prem. n8n: AI nodes + 400+ integrations, wiring up CRM/tickets/databases; plenty of templates. Coze: No-code for bots/helpers; easy promotion to multiple platforms for domestic teams. Opal (Google Labs): Compose mini AI apps/flows in natural language—great for PMs to build quick prototypes.

OCR / Document Structuring (Turn PDFs into “Learnable/Queryable” Markdown)

olmOCR (AI2): Tables/formulas/handwriting support, preserves reading order well; can run locally. MonkeyOCR: Proposes the SRR (Structure–Recognition–Relation) paradigm; fast + strong layout understanding. OCRFlux: Lightweight 3B, excellent multi-page merging and complex layouts; online demo and GGUF available.

Suggested workflow: PDF → (olmOCR/MonkeyOCR) → Markdown → (Dify/Agent) for structured extraction + knowledge base.

Get Started Now

Don’t file this under “to read later.” Pick one scenario + one model and run a small pipeline today. Add one more step a week later, and you’ve built your personal AI production line.

Which one will you ship first? Tell me in the comments.

GPT-5 for Planning & Reviews + Claude Code for Implementation

Aug 8, 2025

Vibe Sparking

Conclusion first: GPT-5 excels at planning, structured design, and review/summary; Claude Code (Sonnet / Opus) is more reliable for hands-on execution and refactoring. In practice, the combo “GPT-5 plans + Claude Code builds + GPT-5 reviews” yields higher efficiency and fewer failures. What’s your take?

Introduction

After the keynote, my first reaction was: GPT-5 isn’t just faster and more accurate—it thinks better. OpenAI exposed minimal reasoning and verbosity as tunable parameters, expanded context windows to 400K tokens with up to 128K output, and embedded Gmail/Google Calendar connectors directly into ChatGPT—available for Team today, with Enterprise/Education on August 14.

Media sentiment is consistent: fewer hallucinations, stronger coding, more “expert-like.” But a caveat—marketing charts backfired. Don’t trust vendor curves blindly; prioritize independent evaluations and real projects.

1. Where does GPT-5 actually excel?

Controllable “thinking intensity”: API adds reasoning_effort="minimal", enabling faster responses without sacrificing much quality; verbosity dials answer length and information density. For engineers, these are your speed/quality knobs.
Much longer “working memory”: 400K context (about 272k in + 128k out) improves long-document handling and long-chain tool use.
Transparent pricing: $1.25 per 1M input tokens; $10 per 1M output tokens; mini/nano are cheaper.
Toolchain collaboration: OpenAI claims substantial gains on complex tool use (τ²-bench telecom scenario: 96.7%), fitting end-to-end agent workflows.
New ChatGPT experience: Mail and calendar connectors, personalized tone/voice, learning mode—lowering friction for everyday and team use.

In short: GPT-5 is a more steerable generalist—able to think shallow or deep on demand, and better at tools.

2. Hands-on impressions (with Claude comparison)

These are subjective notes from real-repo work—feel free to critique.

Blank-page code often misfires: Asking GPT-5 to write large backend blocks can show small API/stack mismatches—things that look right but break at runtime; Claude Code Sonnet / Opus feels steadier at “doing the painstaking work.” Opus 4.1 reports 74.5% on SWE-bench Verified, and it shows.
“Extend/modify by example” works great: Provide the project tree + key files + a minimal working example; GPT-5 follows style and integrates with existing interfaces more reliably, especially for UI/interaction—often green on first pass. Wired and TechCrunch also highlight broad improvements in coding and writing/analysis.
Benchmarks are strong—don’t deify them: OpenAI cites SWE-bench Verified 74.9%, Aider polyglot 88%; third parties show scenarios where GPT-5 ≈ Opus 4.1 ≈ Grok 4—differences vary by task. Don’t ship on scores alone.

My takeaway: I prefer GPT-5 for “blueprints” and “reviews”; for actual wrench-turning, Claude Code is less hassle.

3. Recommended workflow: GPT-5 plans + Claude Code executes

Step 1 | Product/architecture design
Give GPT-5 the business goals, constraints, and non-functionals, and ask for system sketches, interface contracts, failure cases, and monitoring points. Prompt tip:

“Use verbosity=low for the summary; then high to expand risks by module.”

Step 2 | Task breakdown and acceptance
Have GPT-5 produce milestones → tasks → acceptance criteria, and a code change checklist (files, functions, risks).

Step 3 | Hand off to Claude Code
Provide the repo + task card + acceptance criteria to Sonnet/Opus; require branch-based development, stepwise commits, and rollback on failure. Opus 4.1 is particularly stable for multi-file refactors and debugging.

Step 4 | Two-way review
Let GPT-5 handle PR review, test additions, and changelogs; let Claude handle fixes and polish.

Step 5 | Long-chain automation
For complex pipelines (search/retrieval/many tools), favor GPT-5—OpenAI provides fresh evidence on long chains and instruction-following. But add human checkpoints at critical stages—don’t go fully hands-off.

4. When to choose which?

0→1 prototyping, front-end flair, ready-to-ship UX: lean GPT-5 (multiple outlets show stronger front-end generation and “software on demand”).
Large-repo renovations, long-running execution, fine-grained patchwork: lean Claude Code (Sonnet / Opus); the latest versions keep improving on real engineering tasks.
Cross-app coordination and daily office work: ChatGPT (GPT-5) + connectors is smoother.

5. Two sober reminders: avoid glossy charts; don’t worship leaderboards

Keynote charts had issues—OpenAI acknowledged the “chart fiasco.” Rely on the official docs and product pages.
Independent evaluations are incoming: Platforms like Vellum offer grounded cross-model comparisons; winners differ by dataset. Translate the problem into your real workflow—that’s what matters.

Closing

GPT-5 is the “better thinker,” Claude Code is the “better doer.”
Right fit: let GPT-5 set strategy, draft blueprints, and supervise; let Claude Code execute, stitch, and refine.
In 2025, this combo is the most reliable engineering play.

How would you split the work? Share your combo in the comments.

These Claude Code Commands Save Me 5 Hours of Programming Time Every Week

Aug 5, 2025

Vibe Sparking

CCPlugins is a collection of 24 “enterprise-grade” commands maintained by community developer brennercruvinel, specifically crafted for Claude Code CLI. It’s all about saving time, reducing stress, and eliminating bugs. Using conversational syntax, it transforms tedious tasks like security checks, code cleanup, feature scaffolding, and smart commits into simple slash commands. The installation script runs in 30 seconds, and real-world testing shows it can save developers 3-5 hours of mechanical work per week.

🧭 Introduction

“Add a button” and Claude rewrites your entire UI? That’s not uncommon in Claude Code. CCPlugins aims to cage Claude’s ‘infinite imagination’ and make it do exactly what you want.

🔍 What Exactly is CCPlugins?

1. Official Positioning

“Enterprise-grade workflows”: Process-oriented command sets for teams, not just simple prompt macros.
Context templates specifically fine-tuned for Opus 4 / Sonnet 4 models, ensuring stable output.

2. Pain Point Solutions

Traditional Approach	Common Issues	CCPlugins Solution
Manual prompts	Over-engineering / Output chaos	Fixed scripts + validation stage `/refactor validate`
Manual commits	Missing information	`/commit` auto-generates Conventional Commits
Full codebase scans	Time waste	Grep/Glob scans only related files, incremental processing

🚀 30-Second Installation

# macOS / Linux
curl -sSL https://raw.githubusercontent.com/brennercruvinel/CCPlugins/main/install.sh | bash
# Windows
python install.py

Uninstall is just as simple: ./uninstall.sh or python uninstall.py

Tip: The script places all command md files in ~/.claude/commands/. For updates, just run git pull.

🛠️ 4 Core Command Categories

### Development Pipeline

/cleanproject: Instantly delete debug clutter with automatic Git checkpoint backup.
/scaffold user-auth: Read project structure and generate complete feature scaffolding with one command.

### Quality & Security

/review: Four sub-agents perform security, performance, architecture, and maintainability health checks.
/security-scan: Chained vulnerability scanning with fix tracking.

### Deep Analysis

/understand: Auto-generate architecture diagrams and design pattern inventories.
/explain-like-senior: Understand complex code in one sentence, supports multi-file analysis.

### Session & Project Management

/session-start / /session-end: Generate CLAUDE.md with complete iteration history tracking.

✨ 3 High-Efficiency Usage Patterns

Security Guardian
Terminal window
```
claude "/security-scan" && claude "/review" && claude "/test"
```
Let CI run the “scan-review-test” pipeline before merging.
Morning Routine
Terminal window
```
claude "/session-start"
claude "/predict-issues"
```
Start the day by predicting risks before diving into work.
One-Click Wrap-Up
Terminal window
```
claude "/format" && claude "/commit" && claude "/session-end"
```
Unified code formatting + smart commit messages + summary logs for an elegant end to your workday.

🏁 Conclusion

CCPlugins upgrades “one-sentence AI commands” into modular, reusable, auditable workflows, allowing us to truly spend time on design and decision-making rather than debugging and manual grunt work. Why not install it and give it a try?

Claude Code Running in Your Local Browser

Aug 5, 2025

Vibe Sparking

Claude Code Web UI (abbreviated as CUI) brings Claude Code from the terminal into your browser with a modern interface, parallel multi-session support, push notifications, and voice dictation. Simply run npx cui-server to launch, then log in to continue your AI programming tasks from any device.

Introduction

Still stuck having “black screen conversations” with Claude in the command line? CUI upgrades your AI programming experience to a cloud IDE, letting you write prompts, run agents, and receive notifications right in your browser, with mobile device continuity support.

Key Features

✨ Modern Design

Built with React + TypeScript, responsive interface for desktop and mobile.
Auto-completion consistent with CLI, zero learning curve.

🚀 Parallel Background Agents

Supports simultaneous multi-task streaming output, no more queuing for complex projects.

📂 Task Management

CUI scans ~/.claude/ history, centrally displays tasks with one-click Resume / Fork / Archive.

🔔 Push Notifications

Integrated ntfy, instant alerts when tasks complete or await authorization.

🎙️ Gemini 2.5 Flash Dictation

Connected to Google Gemini API, fast and accurate long-sentence voice-to-text.

Three-Step Quick Installation

Environment Setup
- Node.js ≥ 20.19.0.
One-Click Launch
Terminal window
```
npx cui-server
# Or install globally: npm i -g cui-server
```
The terminal will output a #token string, copy it for use.
Browser Access Open http://localhost:3001/#<token> to log in.

TIP: Need remote access? Set server.host to 0.0.0.0 in ~/.cui/config.json, or use --host / --port parameters, then pair with Caddy reverse proxy to upgrade to HTTPS.

Advanced Usage

Parallel Multi-Tasking

Check running sessions in the Tasks tab; long tasks can run in the background after closing pages, no disconnection worries.

Chat Shortcuts

/ for commands, @ for files, maintaining the same muscle memory as CLI.
⌘/Ctrl + Enter to send, space for new lines, small tricks to boost typing efficiency by 10%.

Voice Dictation

Export GOOGLE_API_KEY in your system first, then restart the server to enable voice input.

Real-Time Push

Install ntfy client on any device, subscribe to the same topic, get vibration alerts immediately when tasks finish, no more screen watching.

Conclusion

CUI creates a “browser-visualized shell” for Claude Code’s capabilities, with lightweight installation + remote access + push ecosystem, making AI programming as smooth as browsing the web. What pain points are you most excited to solve with it? Share in the comments!

Unlock Claude Code: Transform Your Development Efficiency from 1× to 100× Engineer

Aug 4, 2025

Vibe Sparking

Introduction

You’ve probably heard this classic take: “A 1× engineer using AI becomes 0.1×, but a 10× engineer using AI becomes 100×.” This isn’t hyperbole—it’s reality, provided you possess key capabilities like systems thinking, precise communication, and architectural design. This article breaks down each element, combining Claude Code’s real capabilities to show you how to amplify AI effectiveness by 100 times.

Scenario 1: Systems Thinking vs File-Level Thinking 🚀

A 1× engineer can only think about “writing a method,” while a 100× engineer maintains the entire system’s state in their mind. Claude Code can instantly establish a holistic view of millions of lines of code. With just one sentence, you can have it “search user permission logic across the project, analyze cross-service dependencies, and generate a PR containing all modifications”—Claude handles the entire codebase-level coordination.

Example You want to switch authToken encryption from HMAC-SHA256 to RSA: Simply say “rewrite token logic with RSA and ensure tests pass green.” Claude Code operates across 5 files in one go: controller, service, utils, and unit tests, creating a coordinated Git commit.

Scenario 2: Communication Precision: The Efficiency Multiplier

A 1× engineer provides vague requirements, forcing Claude to “guess” and “try,” leading to endless iterations.

Those 100× engineers who master engineering-minded communication know that prompts written like good articles enable LLMs to execute precisely.

The Claude team repeatedly emphasizes structured prompts: including background, intent, format, examples, and validation criteria.

Example You want to refactor the calculateScore function while maintaining logical consistency: Provide sample input/output tables, desired PR title templates, and CI validation rules; then tell Claude Code in one sentence: “Based on the following examples and rules, refactor calculateScore and output PR diff, test report, and commit message.”

Result: 99% PR pass rate, 20× reduction in manual curation.

A 1× engineer rushes Claude to write features without looking back, resulting in system crashes; a 100× engineer knows that upfront design is crucial.

Claude Code can combine long-context memory with engineering intent to execute well-designed structural changes—enter MCP (Model Context Protocol), enabling Claude to access your design documents, tickets, architecture diagrams, etc., forming a long-term perspective (state).

Example You plan to split a monolith into service mesh: First write clear documentation + interface contracts + merge strategies, then use Claude Code to step-by-step generate scaffolding, extract logic, generate SDKs and prototype PRs, even auto-generate CI configurations—only passing to you for review after tests pass.

Scenario 4: Context Control: Your Value Multiplication Lever

Stop treating LLMs as autocomplete and start using them as system-level contextual engines. Claude Code embeds Claude Opus 4, capable of fully understanding entire project structures, dependency graphs, naming conventions, style guidelines, even READMEs and issue templates.

Example You want to add a “mobile caching layer” module. Just tell Claude Code to “follow the project’s existing cache-service pattern, generate consistent module + README + unit tests,” and it will recognize the pattern, consistently inserting new code into the architecture.

Scenario 5: True Intelligence and Systems Thinking First, Tool Knowledge Optional

A 1× engineer relies on IDE shortcuts memorization, a 10× engineer switches from Node.js to Go, but a 100× engineer doesn’t enjoy writing code—they enjoy proposing patterns, deconstructing problems, and letting agents execute.

Claude Opus 4 is internally called “the best coding model in the world” at Anthropic, enabling engineers to “persistently complete complex tasks with hundreds of steps within hours”—this is the typical outcome of systems thinking + agent control.

Example You want to rewrite a microservice, migrating from Express to Rust while preserving all original behavioral boundaries: You write requirements and sample data, Claude Code automatically scaffolds the Rust service, generates HTTP interfaces, maps data models, migrates old logic, and even generates comparison tests and deployment configs.

Scenario 6: AI is a Powerful Amplifier—Your Strengths Make AI Stronger, Your Weaknesses Make AI Worse

For 100× engineers, Claude will “learn” your organizational principles, naming conventions, test coverage, documentation style and consistently execute them in every commit. If you write messy English comments and use inconsistent indentation, it will help you continue the mess; if you have discipline, it transforms you into a stylized engine.

Example
Early in your project, you strictly follow <service>.test.js, commit descriptions over 90 characters, complete READMEs and issue templates. Claude Code will be equally strict about marking "BREAKING CHANGE", won’t generate code for untested paths, and automatically reference issue IDs in commits. If the project is chaotic, its generated commits will often be chaotic too—this “mount” follows whoever’s rhythm.

Real community feedback:

“I have mindlessly asked Claude Code over a large codebase … it gave an extremely clear report…” —— Even with poor prompts, clear project structure makes Claude Code quite effective.

Conclusion

Claude Code isn’t just intelligent code writing—it enables you to think about system problems like an architect, communicate design intent precisely, and continuously maintain code standards.
It doesn’t eliminate coding but frees your brain for truly important decisions, delegating heavy repetitive tasks to AI.
When you polish systems thinking, prompt crafting, project structure, test coverage, and engineering standards, Claude becomes your zero-error 100× amplifier.

Claude Code Security Review: Your AI Security Watchdog

Aug 4, 2025

Vibe Sparking

Claude Code Security Review: Making Security Audits as Easy as Writing Commands

Claude Code’s newly released claude-code-security-review integrates Anthropic Claude’s large language model reasoning capabilities directly into GitHub Actions and terminal commands. It can analyze diffs during pull request (PR) stages to identify high-risk vulnerabilities like SQL injection, XSS, and authorization bypasses, while automatically filtering out low-value noise. You can even scan locally with a simple /security-review command. Your code’s potential vulnerabilities are flagged by AI before it even gets merged.

1. What is Claude Code Security Review?

AI-Powered Security Auditing: Leverages Claude’s deep semantic understanding to go beyond regex matching and directly comprehend code intent.
GitHub Action Integration: Automatically triggers on PR opens or syncs, posting vulnerability findings directly to specific code lines.
Terminal Slash Commands: Enter /security-review in Claude Code for the same scanning capabilities to run instantly offline.

2. Core Highlights

1. High Signal-to-Noise Results

Built-in False Positive Filtering automatically screens out low-risk alerts like DoS, resource exhaustion, and input validation with no actual impact, surfacing only the truly critical vulnerabilities.

2. Semantic-Level Vulnerability Detection

Identifies 10 major categories of issues including injection attacks, authentication flaws, hardcoded secrets, weak encryption, and business logic race conditions.

3. Diff-Aware & Language Agnostic

Only analyzes changed files, supports any programming language, making it ideal for multi-language microservice repositories.

4. Zero-Configuration CI/CD

Just one YAML snippet gets you running:

- uses: anthropics/claude-code-security-review@main
  with:
    claude-api-key: ${{ secrets.CLAUDE_API_KEY }}
    comment-pr: true

5. Industry-Wide Recognition

Publications like VentureBeat and The New Stack have noted that as AI-generated code volume surges, automated security auditing has become essential. This Action fills that critical gap.

3. Getting Started

1. Quick GitHub Actions Integration

Create .github/workflows/security.yml in your project root
Copy the YAML above and add CLAUDE_API_KEY to your repository Secrets
Submit a PR to see Claude automatically comment with vulnerability details + fix suggestions

2. Local /security-review Command

In your terminal or VS Code Claude Code panel, enter:

/security-review

This executes the same level of auditing on your current uncommitted changes, perfect for solo development or offline scenarios.

3. Custom Rules

Copy security-review.md from the repository to .claude/commands/
Edit filtering rules or add company-specific security baselines, such as prohibiting weak password algorithms.

4. Real-World Scenarios

Scenario	Trigger Method	AI-Discovered Issues	Outcome
Internal Tool Adding Local HTTP Service	Automated audit before PR merge	DNS Rebinding → RCE	Vulnerability fixed before merge
Legacy Project Refactoring	Terminal `/security-review`	Sensitive log leakage + weak AES-ECB encryption	One-click generation of encryption/log fix patches
Multi-Language Microservice Repo	Every PR	Python dependency poisoning + Node XSS	PR comments list vulnerabilities + npm audit fix commands

5. Final Thoughts

AI writes code fast, but AI must guard security even faster. Integrate claude-code-security-review into your DevSecOps pipeline to ensure every line of code passes through security gates before entering the main branch. The next zero-day might just be the one you keep out.

Claude Code + Backlog.md: Building Git Kanban + AI Collaboration

Aug 3, 2025

Vibe Sparking

Backlog.md + Claude Code transforms any Git repository into a Kanban board + documentation + AI collaboration hub in seconds, with all data stored as Markdown files for offline privacy. This article will get you up and running in 5 minutes, covering installation, core features, and typical workflows to explain why it’s the minimal viable stack for human + AI collaborative projects.

Introduction

Tired of switching between multiple SaaS tools? Backlog.md generates a complete project management system locally with a single command—perfect for individual developers and seamlessly integrates with multi-agent pipelines, allowing Claude and Gemini to directly read and write tasks.

I. Why Choose Backlog.md?

1. Markdown as Natural Task Cards

Each issue is a task-123 - title.md file, ready for Git diff tracking.
Local editors work great, and AI can read them easily.

2. 100% Private & Offline

All files live in your repository with no external dependencies; edit your kanban even on a train.

3. Zero-Configuration Kanban

backlog board renders live queues directly in the terminal.
backlog browser auto-opens a responsive Web UI with drag-and-drop status updates.

4. AI-Ready CLI

Includes CLAUDE.md and other documentation files—just type “Claude, please take over task-33” to assign work.
Supports sub-agents and Ultrathink planning, compatible with popular models.

5. Cross-Platform + Multiple Installation Channels

Choose from npm i -g backlog.md, brew install backlog-md, or nix run.
Homebrew & Fedora packages available simultaneously with fast version updates.

II. 3-Step Quick Start

Step	Command	Description
Initialize	`backlog init "AI Side Project"`	Interactive setup, auto-generates `backlog/` directory
Create Tasks	`backlog task create "Refactor login flow"`	Supports description, assignee, tags, priority, etc.
View Progress	`backlog board` or `backlog browser`	Terminal / browser—two flavors

Tips: Want AI to batch-break down requirements? Paste your PRD to Claude: “Please use ultrathink to split tasks and identify dependencies.”

III. Advanced Usage

1. One-Click Weekly Reports

backlog board export README.md --export-version "v1.0.0" Generates a versioned Markdown kanban that syncs teams immediately when pushed to Git.

2. Multi-Repository Coordination

Use git worktree or sub-repositories to aggregate BE/FE tasks into the same directory; all links still point to original branches.

3. Auto-Commit & Hook Bypass

backlog config set autoCommit true eliminates manual git add/commit.
For strict pre-commit setups, use bypassGitHooks true.

4. Statistics & Dashboard

backlog overview displays task burndown and bar charts in the terminal, giving you instant project health insights.

IV. Use Cases

Independent Developers: Local Git + Markdown, everything on one machine.
Remote Small Teams: Pull Requests sync task status automatically—goodbye Jira.
AI Agent Pipelines: LLMs read/update task files, enabling “planning→coding→PR” closed loops.

Conclusion

Backlog.md uses the most native toolchain to unify project management, documentation, and AI collaboration into one system, helping us refocus attention on “writing code” itself.

Ready to try this “local Git kanban” approach? Share your experience in the comments!

Slash-Commands vs Sub-Agents in Claude Code: Differences and Practical Collaboration

Aug 3, 2025

Vibe Sparking

Have you ever wished you could package common AI operations into shortcuts that execute with a single command, while having AI break down tasks and collaborate through division of labor? Claude Code is precisely such a tool that enables developers to use AI-assisted coding more efficiently, systematically, and enjoyably. Today I’ll discuss its two core features in accessible terms: Slash-Commands and Sub-Agents, explaining their characteristics, usage, and differences, with real examples you can immediately apply.

Slash-Commands: Your Custom AI Shortcut Buttons 🚀

Characteristics and Use Cases

Write custom prompts once, invoke with commands: Package common operations (like code reviews, performance optimization, issue fixes) into .claude/commands/*.md files, and Claude treats these prompts as commands. Simply type /command-name parameters to automatically execute the corresponding workflow.
Parameterization support: Commands can use $ARGUMENTS placeholders that get replaced when you input parameters, flexibly accepting issue numbers, module names, and other arguments.
Project sharing or personal use: Place in .claude/commands/ for project-level commands accessible to the entire team; place in ~/.claude/commands/ for personal private commands.

Example Usage

For instance, you define a /fix-issue command with a template containing the fix workflow:

Fix GitHub issue: $ARGUMENTS.
Please execute the following steps:
1. Use gh issue view to get details;
2. Analyze the problem; 3. Find relevant code; 4. Submit fix; ...

In the command line, type:

/fix-issue 123

Claude will perform Git operations, code modifications, and open Pull Requests - the entire process is automated, saving you countless repetitive steps (you can also choose whether to auto-commit). Perfect for scenarios like repeatedly fixing issues, reviewing PRs, and generating documentation.

Sub-Agents: Multi-Agent System with AI Task Decomposition and Collaborative Division of Labor 🧠

Characteristics and Use Cases

Each sub-agent stays focused: Sub-Agents are “mini Claudes” with independent contexts, specializing in specific task types like performance optimization, test generation, code review, etc., never interfering with the main conversation thread.
Customizable roles, reusable: You can use the /agents command to create sub-agent configurations, each with clear names, descriptions, and permissions (like read-only code access, running tests, calling grep, etc.).
Main agent orchestrates and can chain multiple sub-agents: The main Claude decides which sub-agents execute which tasks based on context, supporting task decomposition with clear responsibilities, with final results aggregated back to the main conversation interface.

Example Usage

Suppose you define several sub-agents:

code-reviewer.md: Only reviews code style and security issues
test-builder.md: Specializes in generating unit tests
debugger.md: Responsible for checking error logs and locating problems

Your conversation with Claude goes like this:

“Please review the auth module” → Main agent calls code-reviewer “Write unit tests for this module” → Calls test-builder “Found test failures, find where the error is” → Calls debugger

Finally, the main agent summarizes the output for you. The entire process is like having a team of AI assistants, each handling their specialty.

Key Differences: Different Invocation Methods, Different Division Perspectives

Aspect	Slash-Commands	Sub-Agents
Invocation Method	Start typing `/` to trigger commands	Automatically used in conversation or explicitly called with `/agents` for specific sub-agents
Usage Threshold	Write templates and use - quite intuitive	Requires defining role descriptions, tool permissions, prompt styles, etc. - more complex
Scenario Focus	Repetitive, standardized workflow tasks	Professional, complex, or decomposable tasks (like testing, review, debugging)
Output Control	Consistent template usage each time, relatively fixed	Can break into multiple stages with different agents handling different segments, more granular output
Maintainability	Template files easy to manage, suitable for team sharing	Sub-agent configuration files complex, requiring version control and synchronized updates

Usage Examples: Collaborative Application in Real Workflows 👩‍💻

Standardized Review Process
- Write a Slash-Command /security-review with templates that automatically check code security points.
- Main agent calls security-review, then triggers code-reviewer sub-agent for detailed output based on circumstances.
Automated Bug Fix + Ticketing
- Slash-Command /fix-issue 456 initiates: Main agent scans GitHub issue → calls debugger to check errors → modifies code → calls test-builder to write tests → finally opens Pull Request.
Module Collaboration Scenarios
- Create frontend-expert sub-agent focused on React component optimization, create backend-optimizer sub-agent responsible for API performance.
- When the project needs a new feature, main agent runs one workflow letting both sub-agents produce their respective solutions, then aggregates for your decision-making.

Usage Recommendations

Slash-Commands are your shortcut command buttons, suitable for repetitive, standardized operations Sub-Agents are your behind-the-scenes AI team, capable of task decomposition, multi-perspective analysis, and specialized division of labor

I recommend starting with Slash-Commands: Put your most frequent operations into commands and share template files with your team. After becoming proficient, gradually introduce sub-agents to handle complex workflows through task decomposition, with the main agent orchestrating while you maintain control. This approach avoids detours and prevents initial tool overwhelm.

For small teams or short projects, one or two Slash-Commands and simple sub-agents are quite sufficient; for long-term projects or multi-person teams, you can gradually expand into a complete AI collaboration pipeline. It’s like hiring a reliable AI assistant team - both development efficiency and standardization will improve significantly.

Claude Code Cookbook: Automated Commands + Multi-Role System + Intelligent Hooks

Aug 2, 2025

Vibe Sparking

Build Your Personal Claude Programming Operating System

💡 Introduction

Many people use Claude Code for programming, but have you ever felt that:

Despite Claude being powerful, you always have to guide it step by step
Every time you need testing, documentation updates, or PR generation, you have to remind it manually
Role switching becomes chaotic and actually reduces efficiency instead of improving it

Recently, Japanese engineer @wasabeef released an incredible project — claude-code-cookbook, transforming Claude Code into an “automated development assistant” that works fast, provides accurate feedback, and thinks clearly.

This isn’t just another prompt template collection, but Claude’s “extended operating system.”

👇 I’ve been testing it for several days and it’s absolutely impressive. Highly recommended for anyone using Claude for development projects!

🔧 Three Core Features: Unlocking Claude’s Hidden Capabilities

🧾 1. Commands: Make Claude Follow Your Instructions

Simply type /command-name and Claude will execute the corresponding task.

For example:

Command	Function
`/explain-code`	Automatically explain code logic
`/fix-error`	Generate fixes based on errors
`/commit-message`	Auto-write Git commit messages
`/pr-create`	Auto-generate PR content
`/check-prompt`	Help optimize your prompts
`/semantic-commit`	Semantic commits for better version control

These commands alone can eliminate countless repetitive conversations.

💡 Each command is essentially a Markdown file that supports custom extensions—just place them in the commands/ directory.

🎭 2. Roles: Multi-Role Switching, Claude as Professional Consultant

Claude supports switching between different roles like “sub-personalities,” such as:

/role qa Test Engineer
/role mobile Mobile Development Expert
/role security Security Consultant
/role architect System Architect

🌟 The highlight: supports concurrent execution!

/role performance --agent
/role security --agent

Claude will simultaneously launch multiple roles for parallel analysis and provide unified recommendations. This is incredibly useful for large project reviews and design assessments.

⛓ 3. Hooks: Automated Scripts for Maximum Development Experience

You can set up script hooks that run automatically at specific moments.

For example:

check-ai-commit.sh: Prevents AI signatures from appearing in Git commits
preserve-file-permissions.sh: Automatically saves/restores file permissions
auto-comment.sh: Prompts to add docstring comments

Even thoughtful touches like “task completion notifications” are included:

osascript (macOS notification script)

In short, Claude truly becomes a reliable partner that handles chores, provides reminders, and writes code.

🧪 Complete Project Automation Workflow

👇 The project includes a comprehensive development workflow diagram, from task identification to CI status tracking, all seamlessly integrated:

You can even follow this logic to customize your team’s “Claude development pipeline.”

🚀 How to Use?

Installation and Configuration Are Super Simple:

Clone the repository:

git clone https://github.com/wasabeef/claude-code-cookbook.git ~/.claude

Set the path in Claude client
Modify settings.json to mount hooks and extend commands

🛠 Adding custom commands and roles simply requires writing .md files in the corresponding folders—very easy to get started.

🧠 Summary: Transform Claude into Your Engineering Co-Pilot

Claude Code Cookbook brings a systematic development workflow that enables you to:

Efficiently organize project tasks with Claude automatically following up
Freely switch between professional roles to handle different work scenarios
Automate scripts to completely free your hands

For everyone doing serious development with Claude, this is a game-changing tool for boosting efficiency and professionalism.

📣 What commands would you most like to customize for Claude? Feel free to share in the comments and let’s build smarter Claude assistants together!

If you enjoy these AI tool tips, remember to share with your tech-savvy friends!

Claude Code Beyond Coding: Running My Daily Life

Aug 1, 2025

Vibe Sparking

Still using Claude Code just for writing code? I’ve moved on to using Claude Code for managing my entire life.

This isn’t a joke—I’ve built a complete “life operating system” with Claude Code that effortlessly manages my daily routines, captures inspiration, tracks goals, and even takes care of my mental wellbeing.

With just 10 minutes of setup, Claude helps me complete countless small but important tasks every day.

👀 Five Examples That Show Claude’s Power

✅ Weekly Check-in

Claude automatically generates my growth dashboard each week: video view counts, writing word counts, income changes, and more.

📌 Usage: Run /weekly check-in command, and Claude generates charts + key insights, even recommending content topics!

Highlight: Like a personal coach who never complains—cheers me on every week while offering helpful suggestions.

✍️ Daily Journal

Spend 2 minutes daily as Claude guides me through recording the day’s learnings, reflections, and feelings, while tracking my emotions and habits.

📌 Usage: Run /daily check-in, answer a few questions, and your journal is automatically organized.

Highlight: Builds self-awareness and gratitude habits, keeping emotional drain at bay.

📚 Content Research

I just paste a few competitor links, and Claude helps me write my own content drafts.

📌 Usage: Use /newsletter researcher command—it analyzes my style, incorporates my unique traits, and generates new drafts.

Highlight: Saves 80% of research and ideation time. No waiting for inspiration—Claude finds it for me!

🧠 Brain Dump Analyzer

Too many scattered notes? Claude automatically organizes them into mind maps or article outlines, even uncovering hidden insights.

📌 Usage: Import notes into Claude, run /brain dump analysis command.

Highlight: Transforms “fragmented notes” into “business opportunities.”

📰 Daily Brief

Claude curates industry updates, news, and creative inspiration based on my interests, delivered every morning on schedule.

📌 Usage: Set up /daily brief command—it automatically searches and organizes content.

Highlight: No need to scroll through X/Twitter/social feeds—Claude delivers everything in one package.

🧰 Build Your “Life Operating System” in 10 Minutes

Prepare Environment Install Claude Code (recommend using VS Code, Cursor, etc.), create a personal information markdown file.
Initialize Configuration Run /init command, Claude will generate rule files.
Set Up Slash Commands Copy prompts from Google Docs, like /weekly check-in, /daily brief, etc.
Run and Customize Execute these commands daily/weekly—Claude runs automatically. I can even have it generate more custom agents!

🚀 Why This System Is Worth Trying

Time Savings: Save hours each week by letting AI handle routine tasks.
Highly Personalized: Claude Code customizes outputs based on my interests and work style.
Low Technical Barrier: No coding required—just copy prompts and use.
Infinite Scalability: Can expand into meeting note assistants, todo list generators, and more.

🧠 Real Usage Tips

Beginner-Friendly: Prompts are crystal clear—newcomers can follow along easily.
Customize for Yourself: Try incorporating tools and workflows from your daily work—Claude Code excels as a “personal assistant.”
Keep It Running!: Set commands to run automatically daily—Claude Code gets to know you better over time.

🗣️ What Do You Think?

What would you most want Claude Code to do for you?

Beat the Weekly Limits: Spin Up Your Own Claude Relay Service

Jul 30, 2025

Vibe Sparking

TL;DR

Anthropic just introduced “weekly quotas,” and shared team accounts can hit limits in just 3 days. Build your own claude-relay-service proxy with multi-account pool auto-rotation to bypass the latest restrictions. Deploy with Docker-Compose in 3 minutes, give everyone their own API key, and keep coding all week long!

The Quota Storm - Power Users in Panic

Starting August 28th, Claude Code subscriptions include “weekly metering”; Anthropic specifically targets 24/7 background scripts and account sharing
Anthropic estimates less than 5% of users affected, but heavy developers are likely to get hit
Pain point: Multiple users sharing one account → quota spikes → early limits → team development halts

Are you worried about sudden “service interruption”? Share your experience in the comments 👇

Why Choose claude-relay-service?

Key Capabilities

Feature	Scenario Value
Multi-account Pool & Auto-rotation	No fear of hitting limits even with N shared accounts
OpenAI/Claude Dual API Format	Zero code changes for existing projects
One-click OAuth Authorization	New accounts in the pool in 30 seconds, no more manual cookies
Per-key Billing Statistics	Precise tracking of token usage per user, no more arguments over costs
Client Whitelist	Prevent key leaks and script abuse

Risk Warning: Self-hosted relays may violate Anthropic ToS. Use at your own risk.

3-Minute Docker-Compose Quick Installation Guide

Just copy and run

Prepare the project

# Clone the project
git clone https://github.com/Wei-Shaw/claude-relay-service.git

# Enter directory
cd claude-relay-service

# Copy .env.example
cp .env.example .env

Modify .env (must change to random values)

# Required: Security keys (change to random values)
JWT_SECRET=your-random-secret-key-at-least-32-chars
ENCRYPTION_KEY=your-32-character-encryption-key

# Optional: Admin credentials
ADMIN_USERNAME=cr_admin
ADMIN_PASSWORD=your-secure-password

One-click startup

docker-compose up -d

After startup, open http://<server-IP>:3000/web in your browser, or locally http://localhost:3000/web. The logs will show the auto-generated/custom admin account.

Web interface preview after login:

Management Dashboard

API Keys Management

Account Management

Usage Guide

How to Use

One Key Per Person: Generate API keys for each team member in the “API Keys” panel, with rate/model limits to prevent abuse.
Environment Variables: Set ANTHROPIC_BASE_URL to http://localhost:3000/api/ and ANTHROPIC_AUTH_TOKEN to the generated key in environment variables, no business code changes needed.

# Environment variables
export ANTHROPIC_BASE_URL="http://localhost:3000/api/"
export ANTHROPIC_AUTH_TOKEN="cr_<your_token>"

# Start Claude Code
claude

Monitoring Dashboard: Real-time token consumption tracking, quota alerts to prevent sudden limits.

Cost Estimation & Risk Mitigation

Item	Price/Period	Notes
2-core 4GB Light Cloud	¥30-60/month	Sufficient for Relay+Redis
Claude Max $200	Can be shared	Per-person cost decreases with more users
Domain+CDN	Optional	Needed for public HTTPS

Compliance Reminder: Anthropic has explicitly prohibited reselling and account sharing; accounts may be banned or throttled if abnormal traffic is detected.

Quotas Are Here, Efficiency Shouldn’t Drop

Deploy your own “mini-relay” now and keep quota control in your hands. Forward this to colleagues worried about throttling - let’s maximize usage together!

Discussion Question

How are you planning to allocate keys & quotas? Share your strategies in the comments ~

Claude-Code-Remote: The Ultimate Guide to Controlling Claude Code via Email, Discord & Telegram

Jul 29, 2025

Vibe Sparking

TL;DR

Claude-Code-Remote brings terminal-based Claude Code to “Email / Discord / Telegram”, letting you remotely send commands, receive progress updates, and continue tasks while lounging on the couch scrolling your phone, truly enabling 24 × 7 remote collaboration and long-task hosting.

Introduction

Running Claude Code for unit tests, refactoring, and document generation takes tens of minutes, even hours. Previously, you had to sit in front of your computer watching tmux windows. Now, just one email gets you “task completed” notifications, and you can reply to the email with new commands — this is the experience Claude-Code-Remote delivers.

What Makes Claude-Code-Remote Different?

1. Pure Email/IM Control, Zero VPN Constraints

Tasks automatically send email/private message notifications when completed, no fear of network disconnections.
Reply to an email from the subway to keep Claude working.

2. Plug-and-Play, No Changes to Claude Core

Injects notifications and commands through settings.json’s Hook mechanism, no conflicts with official CLI upgrades.

3. Secure and Controllable

Only whitelisted emails/users can send commands;
Each command maps to an independent tmux Session, no interference.

4. Multi-Platform Ecosystem

Community extensions like Web UI and Discord Bridge are available, ready to integrate more communication scenarios.

Typical Use Cases

Scenario	Pain Point	Claude-Code-Remote Solution
Long Unit Tests / LLM Auto Refactor	Wasting time waiting locally	Results via email → Reply to email for next step
Emergency Bug Fix While Traveling	Can’t SSH to corporate network	Send commands via Discord/Telegram, remote tmux executes instantly
Multi-Location Code Review	Large time zone differences	Start Claude at office during day, receive summary on phone at night and batch reply with optimization points

Three-Step Quick Start

Step 1: Installation

git clone https://github.com/JessyTsui/Claude-Code-Remote.git
cd Claude-Code-Remote && npm install

Step 2: Configure Email & Whitelist

cp .env.example .env
# Fill in SMTP / IMAP / ALLOWED_SENDERS

Gmail users don’t forget to apply for App Password

Step 3: Add Hook to Claude Code

Append to ~/.claude/settings.json:

"hooks": {
  "Stop": [{
    "command": "node /path/claude-remote.js notify --type completed"
  }],
  "SubagentStop": [{
    "command": "node /path/claude-remote.js notify --type waiting"
  }]
}

Then:

npm run relay:pty     # Monitor email
tmux new -s project && claude   # Start Claude normally

Done! From now on, Claude will send you notifications when tasks finish, just “Reply to original email → Next command”.

Advanced Usage

Combine with Claude-Code-UI: Visualize file tree and history on mobile browser.
Discord Slash Commands: Team control of Claude, supports image uploads.
Telegram Bot Automation: Use /deploy to trigger CI/CD with one click.

Summary

Claude-Code-Remote breaks down “waiting → notification → secondary command” into three parts, using the most universal email/IM channels to completely decouple Claude from the terminal, letting AI agents truly run in the background while humans focus on high-value decisions. If you’re tired of staring at dark Shell windows, install it and give it a try!

How much time do you think this remote control method could save you? 👇 Share in the comments — your real-world experience might become the next case study!

Bring Claude Code to Phone & Web: A Hands‑On Guide to Claude Code UI

Jul 29, 2025

Vibe Sparking

TL;DR

Claude Code UI is an open-source Web/mobile interface that connects to the Claude Code CLI on local or remote servers, providing conversation, file and Git browsing, built-in Shell, session management and other capabilities; high-risk tools are disabled by default, supporting on-demand enabling and permission control. The project uses GPL-3.0 license and is actively maintained.

It brings the terminal-based Claude Code to browsers and phones, helping you manage sessions and projects more conveniently on any device.

Why Do You Need Claude Code UI?

Break Free from Pure Command Line Limitations: Official Claude Code is primarily CLI-based, powerful but not friendly to beginners/mobile users; UI structures it into web pages, lowering the operational barrier.
Cross-Device Lightweight Remote Usage: View projects, switch sessions, review changes on iPad/phone, suitable for commuting, meetings, or outdoor scenarios.
Centralize Common Development Actions to One Interface: Conversation, file editing, Git operations, terminal and session history are centrally presented, reducing context switching.

Core Advantages & Features

Desktop & Mobile Responsive Responsive layout, usable on desktop/tablet/phone, can be added to home screen as shortcut (PWA experience).
Conversational Interface + Real-time Streaming Output Built-in chat panel and session management, supports resuming historical sessions, viewing timeline and metadata.
Integrated Shell Terminal Directly access Claude Code CLI’s command line capabilities within the UI (like executing tasks, viewing logs).
File Browsing & Online Editing Left sidebar file tree, syntax highlighting, read/write/save, create/rename/delete files and directories.
Git Browsing & Basic Operations View, stage, commit and switch branches in the interface; recent versions also added push/pull/fetch.
Project & Session Auto-Discovery Automatically collect projects from ~/.claude/projects/; sessions auto-persist and can be exported.
Secure Defaults & Permission/Tool Switches All tools disabled by default, enable individually as needed in settings; supports alignment with Anthropic’s Permission Modes (introduced in Plan mode updates).
Authentication & Multi-User Ready Starting from 1.1.4, introduced login/registration flow with SQLite-based authentication and protected routes.
Continuous Iteration As of v1.5.0 (2025-07-13), supports adding MCP servers in settings; previous versions included version management prompts, Vite 7 upgrades, etc.

Note: The official installation page states Node.js 16+, while the repository README requires Node.js 20+; follow the repository README, recommend using Node.js 20+.

Typical Use Cases

Mobile Quick Processing: Check Claude’s execution progress, add prompt words, fine-tune files on phone during commute.
Remote Project Inspection: Connect directly to Claude Code on cloud hosts or office computers via browser, view logs, submit small fixes.
Code Review & Teaching Demonstrations: Show Claude’s reasoning process, changes and Git history through UI, reducing team communication costs.
Integration with Other Ecosystems: If you’re already using Claude Code CLI or SDK/reference docs, UI makes it “visible and clickable”.

Quick Start (10 Minutes)

Prerequisites: Ensure you have installed and can use Claude Code CLI (official Anthropic).

Install Claude Code CLI

npm install -g @anthropic-ai/claude-code
# Follow official documentation for authentication and configuration

Prepare Runtime Environment (Recommend Node.js 20+) Install Node.js ≥20, clone repository and install dependencies:
Terminal window
```
git clone https://github.com/siteboon/claudecodeui.git
cd claudecodeui && npm install
```

Configure .env

cp .env.example .env
# Set port, host, reverse proxy/HTTPS etc. as needed

Start Service and Access

npm run dev
# Access http://localhost:your-configured-port in browser

First-Use Recommendations
- In the left project list, confirm UI has auto-discovered ~/.claude/projects/.
- Open the gear icon in top-right, only enable necessary tools, follow principle of least privilege.
- For Git sync needs, use Git panel to view/stage/commit, use push/pull/fetch when necessary.
Install as “App” on Mobile “Add to Home Screen” in mobile browser for PWA experience closer to native app.

Security & Operations Best Practices

Secure by Default: Tools disabled by default, enable individually; follow Anthropic’s Permission Modes.
Authentication & Access Control: Enable login/registration (from v1.1.4), limit public network access, prioritize internal network/SSH tunnel/reverse proxy.
Version Updates: UI includes update checking and prompts, follow prompts to git pull && npm install for upgrades.
Consistent Environment Requirements: Follow repository README’s Node.js 20+ requirement, avoid incompatibility from outdated official website information.

Conclusion

If you’re already using Claude Code CLI, Claude Code UI can significantly reduce friction in cross-device management and collaboration.

Bad News for Cheaters: Claude Code’s Weekly Cap Ends Account Sharing

Jul 29, 2025

Vibe Sparking

Summary: Anthropic announced that starting August 28th, Claude Code subscribers will face additional “weekly caps” with separate weekly limits for the top-tier Opus 4 model. The company directly stated: some people treat Claude as a “24×7 coding mining machine” and even share accounts and resell quotas. The new rules aim to “only affect less than 5% of users,” but have ignited the developer community — many “freeloader exploiters” lament they can no longer harvest GPU computing power.

Introduction

Remember the days of unlimited Claude Code access through “shared accounts + automated scripts”? Those good times are over. Anthropic sent emails to subscribers announcing a stricter weekly cap system, with just one reason: fairness + stability.

“Some power users run Claude in the background 24 hours a day, even reselling access permissions, slowing everyone down.” — Official email

Policy Details

Change	Old Rules	New Rules (Starting Aug 28)
Short-term Limits	Refresh every 5 hours (unchanged)	Remains unchanged
Overall Weekly Cap	None	Refresh every 7 days
Opus 4 Weekly Cap	None	Separate weekly limit

Expected Impact: < 5% of high-intensity users.
Max 5× Tier: About 140–280 hours of Sonnet 4, 15–35 hours of Opus 4 per week.
Overage Solution: Can “extend life” at standard API rates.

Why Did Anthropic Take Action?

1. Account Gray Market Rampant

The community has seen “monthly card proxy services” and “multi-user group buying” gray market services, seriously violating TOS.

2. GPU Resources Under Strain

Claude Code user base surged, with official status page showing 7 outages in one month.

3. Operating Costs Skyrocketing

TechCrunch pointed out that similar services like Cursor and Replit were forced to change pricing in June; Anthropic’s move is “catching up.”

Impact on Developers

Regular Users

Basically No Impact: Daily Q&A, bug fixes, script generation — weekly quotas are sufficient.

Heavy / Team Users

Long-running Agents, large single-repository refactoring, parallel multi-instances — high probability of hitting limits.
Backup Plans: Split tasks in advance, or switch to local LLM/other cloud models as fallback.

”Freeloader” Nightmare Analysis

Strategy	Old Benefits	New Risks
Group Sharing	Low-cost GPU harvesting	Weekly caps make groups hit limits faster
Reselling Compute	High buy, low sell profit	Accounts easily flagged, reputation zeroed
24×7 Agents	Long-term point/ranking farming	Weekly caps lock down, profits plummet

VentureBeat revealed: Some users ran “tens of thousands of dollars” worth of compute time on $200 plans.

In short: Freeloaders are no longer profitable.

Response Strategies

Monitor Usage: Build custom tracking scripts to avoid “mid-week lockout.”
Optimize Prompts: Compress context, use streaming chain-of-thought, reduce wasted tokens.
Multi-Model Combination: Use Sonnet 4 for routine tasks, activate Opus 4 for high complexity.
Private Backup: Deploy lightweight models (like DeepSeek Coder, Phi3 mini) locally for emergencies.

Industry Chain Reaction

Stricter Pricing: OpenAI reduced GPT-4 mini limits in June; BigCode platforms also gradually set weekly caps.
Resource Race: AI companies frantically add data center CAPEX to balance increasingly inflated inference costs.

Conclusion

Anthropic’s move, while ostensibly targeting “freeloaders,” is essentially a resource redistribution in the era of computing scarcity: letting 95% of normal users enjoy stable experiences while making ultra-high-frequency players pay for their usage. Will this reduce your reliance on Claude Code? Welcome to share your thoughts in the comments!

Interaction:

How many hours do you use Claude per week?

If you hit the cap, which tool would you switch to?

Claude Relay Service: The Ultimate Team Account Sharing Solution

Jul 29, 2025

Vibe Sparking

Learn how to implement team Claude account sharing using claude-relay-service, with a focus on docker-compose deployment methods

Introduction

What happens when your team wants to use Anthropic’s Claude AI together, but struggles with account sharing limitations or regional restrictions preventing direct access to Claude? This was exactly the dilemma faced by colleagues Li and Wang: they had pooled resources to subscribe to Claude’s premium tier, but figuring out how to safely and efficiently share access among team members was proving challenging. To make matters worse, many third-party Claude mirror services on the market are often unstable and pose privacy risks. Fortunately, the open-source project Claude Relay Service has emerged as a game-changer, making it possible for teams to build their own Claude relay service! It supports consolidating multiple Claude accounts in one place for shared team use, while providing OpenAI-compatible APIs for easy integration with various applications. This article will dive deep into the project’s core features and usage methods, guiding you step-by-step through building your own Claude relay station to achieve efficient team Claude account sharing. After reading this guide, you’ll discover that sharing Claude with teammates is like co-leasing an “AI supercar” – both cost-effective and worry-free!

Core Features and Capabilities

Claude Relay Service acts as your self-deployed Claude “relay server” – like a butler that manages multiple Claude accounts and provides unified API endpoints for team access. Here are its key capabilities:

Team Account Pool & Multi-Account Rotation: Supports adding multiple Claude accounts to form an account pool, with the service automatically rotating through them to handle requests. This means if one account reaches its usage limit or encounters issues, the system will intelligently switch to the next account, ensuring uninterrupted service. When teams share Claude accounts, each person’s requests are evenly distributed across different accounts, significantly reducing the risk of individual account bans.
OpenAI API Compatibility: Claude Relay Service provides both native Claude interfaces and OpenAI-compatible interfaces. This means you can call Claude using OpenAI API format! For example, by pointing third-party applications’ API endpoints to http://<your-server>:3000/openai/claude/v1/, you can use Claude models just like calling OpenAI. This feature enables seamless integration of existing AI tools with Claude, eliminating the need to modify code for new interface compatibility.
Custom API Keys: For convenient team management, administrators can generate independent API Keys for each user. Team members access Claude Relay Service using their respective keys, while the relay service tracks request counts and token usage for each key. Administrators can set access permissions and rate limits, such as maximum requests per minute, monthly token quotas, or restrict which models are available. This approach allows teams to share Claude accounts while maintaining individual usage tracking and preventing resource conflicts, giving administrators clear visibility into each person’s usage patterns.
OAuth Quick Account Addition: Adding Claude accounts to the account pool is incredibly simple. Claude Relay Service integrates Anthropic’s OAuth authorization flow: administrators click “Add Account” in the web interface, generate an authorization link, then log into their Claude account to authorize and integrate it into the service. The entire process requires no manual password entry – secure and convenient. Note that if your server is located in regions with restricted access, completing OAuth authorization may require VPN assistance. With OAuth integration, even as teams add new members or change Claude accounts, administrators can complete configuration in minutes with seamless transitions.

These combined features create a secure, efficient, flexible, and controllable Claude sharing platform. For small teams unable to directly access Claude’s official service who want to share Claude subscription costs, this is undoubtedly a blessing! Claude Relay Service lets you avoid unstable third-party mirrors while maintaining control over your data and costs. As the official README states: data security, controllable performance, transparent costs – the benefits of self-hosted services are clear at a glance.

Docker Compose Deployment Guide

Claude Relay Service offers multiple deployment options, with Docker Compose deployment being one of the simplest and most efficient choices. Let’s use Docker Compose as an example to build your Claude relay service from scratch.

1. Environment Preparation: Ensure your server has Docker and docker-compose tools installed. Since we’re using Docker containers, the operating system doesn’t matter much – as long as it can run Docker. The official recommendation is to use overseas cloud servers (US nodes) for direct access to Anthropic’s Claude service. Before deployment, you’ll need to register at least one Claude account and subscribe to the appropriate plan (teams typically choose Claude Pro or Max plans and split the costs). Additionally, prepare two security keys: JWT_SECRET and ENCRYPTION_KEY, used for JWT signing and sensitive data encryption respectively – these must be random strings with sufficient length (32+ characters).

2. Get Project Image: The project provides pre-built Docker images that can be pulled directly:

docker pull weishaw/claude-relay-service:latest

The image supports both AMD64 and ARM64 architectures. Once pulled, we can run it using Docker Compose.

3. Write Configuration: Create a .env file in your deployment directory with the environment variables we prepared:

# .env file example content
JWT_SECRET=your-random-secret-key-at-least-32-chars
ENCRYPTION_KEY=your-32-character-encryption-key

# Optional: preset admin account (random generation if not set)
ADMIN_USERNAME=cr_admin
ADMIN_PASSWORD=your-secure-password

Above, JWT_SECRET and ENCRYPTION_KEY are required fields – please replace them with your own random keys. ADMIN_USERNAME and ADMIN_PASSWORD are optional; if not set, the system will automatically generate default admin credentials on first startup and store them in the mounted data volume for reference.

Next, create the docker-compose.yml configuration file:

version: '3.8'
services:
  claude-relay:
    image: weishaw/claude-relay-service:latest
    container_name: claude-relay-service
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - JWT_SECRET=${JWT_SECRET}
      - ENCRYPTION_KEY=${ENCRYPTION_KEY}
      - REDIS_HOST=redis
      - ADMIN_USERNAME=${ADMIN_USERNAME:-}
      - ADMIN_PASSWORD=${ADMIN_PASSWORD:-}
    volumes:
      - ./logs:/app/logs
      - ./data:/app/data
    depends_on:
      - redis

  redis:
    image: redis:7-alpine
    container_name: claude-relay-redis
    restart: unless-stopped
    volumes:
      - redis_data:/data

volumes:
  redis_data:

The Compose file above defines two services: claude-relay and redis. Let’s explain each field:

Images and Containers: The claude-relay service uses our pulled official image weishaw/claude-relay-service:latest, naming the container claude-relay-service for easy identification. The redis service uses the official redis:7-alpine lightweight image as the backend database. Both services have restart: unless-stopped set to ensure automatic restart on abnormal exits, guaranteeing high availability.
Network Ports: ports maps the container’s internal port 3000 to the host’s port 3000, meaning after startup you can access Claude Relay Service’s API and web management interface via http://<server-IP>:3000.
Environment Variables: environment lists the environment variables required by Claude Relay Service. ${JWT_SECRET} and ${ENCRYPTION_KEY} read corresponding values from our .env file. REDIS_HOST=redis specifies the service should connect to the container named redis as its database. ADMIN_USERNAME and ADMIN_PASSWORD use ${VAR:-} syntax, meaning if these variables are provided in .env, use those values; otherwise leave empty for automatic admin account creation. By centralizing configuration through environment variables, no sensitive information is hardcoded in images, and configuration changes are convenient.
Volume Mounting: Claude Relay Service writes logs and data to /app/logs and /app/data directories within the container respectively. We mount the host’s ./logs and ./data directories to corresponding container paths via volumes, achieving log and data persistence. This ensures that even if containers restart or upgrade, previous conversation content, account configurations, and other data won’t be lost.
Service Dependencies: depends_on: - redis indicates the Claude Relay service should wait for the Redis service to be ready before starting. This ensures the application can successfully connect to the database on startup without worrying about startup order issues.
Named Volumes: The volumes: redis_data: at the bottom defines a persistent volume for storing Redis data files. The Redis container mounts this to its /data path, allowing Redis data to be shared/persisted across containers.

With the configuration files ready, you can see they already cover admin account initialization, data persistence, built-in Redis, health restarts, and more. Docker Compose helps us handle all these deployment complexities in one go – worry-free and effortless.

4. Start Services: In the directory containing the above files, execute:

docker-compose up -d

Docker will pull the Redis image and start both containers. On first startup, Claude Relay Service will automatically initialize admin credentials. If we didn’t preset admin credentials in .env earlier, we can get the default account by checking logs or files:

docker logs claude-relay-service    # Find initial admin account in container logs
# Or check mounted data files
cat ./data/init.json

The logs or files will display the admin username (typically defaults to cr_admin) and a randomly generated password. With admin credentials in hand, open http://<server-IP>:3000/web in your browser to access the web management interface. Enter the admin account to log in and start configuring your Claude Relay Service!

5. Add Claude Accounts: After logging into the admin backend, first integrate Claude official accounts into the system. In the “Claude Accounts” tab, click “Add Account”, then click “Generate Authorization Link”. The system will redirect to Anthropic’s official OAuth page, prompting you to log in and authorize. Use the Claude account you want to share to complete authorization, which will return an authorization code. Paste this back into Claude Relay Service’s add account page to successfully bind the account. The entire process is similar to using third-party apps to log into Google – secure and convenient. Pro tip: If your server is in regions with restricted access, this step may require VPN assistance, otherwise you won’t be able to open Anthropic’s authorization page.

6. Distribute API Keys: With the account pool ready, you can create individual API Keys for team members. In the admin backend, go to the “API Keys” tab, click “Create New Key”, name it (e.g., “Zhang San’s Key”), then generate. You can also set permissions and quotas for that key during creation, such as maximum requests per minute, concurrency limits, available models, client binding, etc. After saving, the system generates a random API key string. Team members can then use this key to call Claude Relay Service’s API endpoints, and the relay service will query Claude on their behalf.

After completing these steps, a fully functional Claude team sharing relay service is successfully deployed! Wasn’t the entire process quite streamlined? With Docker Compose, we barely need to manually configure complex environments – one command starts all services. The official team thoughtfully considered automatic initialization and data persistence in the Compose template, making it ready to use out of the box.

Best Practices

To maximize Claude Relay Service’s effectiveness in team collaboration, here are some lessons learned to share:

Smart Account Pool Planning: Use multiple Claude accounts to build your account pool, ensuring they have the same subscription tier (e.g., all Claude Pro/Max subscribers) so rotation won’t be hindered by individual account performance limitations. Account quantity can be adjusted based on team size and request frequency – more people means more accounts for stability. Don’t worry about account idle time; as they say, “multiple Claude accounts on patrol means no fear of bans” – even if individual accounts get temporarily suspended by risk controls, backup accounts can step in to maintain uninterrupted service.
Leverage Usage Statistics: Administrators should regularly check Claude Relay backend’s usage statistics to understand each API Key’s request volume and token consumption. This helps maintain transparent accounting within the team: when everyone splits Claude subscription costs, everyone has a clear “understanding of the books.” If you notice abnormally high request volumes during certain periods, you can communicate promptly or adjust rate limits to prevent one person from “monopolizing” resources and affecting others.
Set Access Controls: Claude Relay Service supports rich usage restrictions for each API Key. Make good use of these features – for example, limiting individual users to no more than N requests per minute, or allowing only specific clients/applications to use them – to prevent misuse and abuse. Especially when opening access to more people or integrating with third-party applications, be sure to configure proper rate limiting and concurrency controls to protect backend Claude accounts from overload and prevent team conflicts over resource competition.
Monitor Network and Latency: Recommend deploying the service in regions with fast access to Claude servers (such as North America). If your team primarily uses it domestically, consider choosing relay routes friendly to domestic users. For example, deploy in the US but use optimized return networks to reduce latency during API calls. Based on practice, some domestic cloud providers’ overseas machines may be blocked by Claude’s Cloudflare firewall, so pay attention to official channel announcements or community feedback.
Stay Updated: This project is very active with continuously improving features (such as recently added Claude-1.2 model support, etc.). Recommend regularly following the project’s GitHub homepage or Telegram announcement channels. Docker users can periodically docker pull to get the latest images, then restart services to upgrade. Staying current allows you to enjoy more stable performance and latest feature capabilities.

Final reminder: Using Claude Relay Service constitutes unofficial Claude API access – please be sure to comply with Anthropic’s terms of service and avoid abuse that could risk your accounts. Self-hosted services give us greater freedom but also mean taking responsibility for security and compliance ourselves. Establish good usage guidelines within your team to ensure long-term “happy Claude usage”!

Conclusion

With Claude Relay Service, we no longer need to rack our brains over team Claude account sharing. Whether you’re unable to directly access Claude due to regional restrictions or want to split the cost of expensive Claude Max subscriptions with teammates, this open-source project provides a flexible, reliable, secure, and private solution. We’ve detailed its core features: multi-account pools, OpenAI interface compatibility, custom API keys, OAuth account addition, and more, showing you clearly how it meets team collaboration needs. At the same time, we’ve demonstrated Docker Compose deployment step-by-step, from configuring environment variables to starting services – we believe even readers who aren’t DevOps experts can follow along and quickly set up their own Claude relay station.

It’s easy to imagine that with Claude Relay Service, late-night coding sessions no longer fear Claude account quota depletion, and colleagues don’t need to each open separate accounts and pay duplicate fees. Everyone shares one “Claude resource pool,” taking what they need while keeping everything transparent and clear – truly achieving cost savings and peace of mind!

Unlock Claude Code's Thinking Modes: From 'think' to 'ultrathink'

Jul 28, 2025

Vibe Sparking

When used well, think is your secret weapon for breaking through bottlenecks; when used poorly, Claude works like it “left its brain at home”.

Have You Ever Had This Experience?

You ask Claude to help analyze a problem, and it gives you an answer in three sentences.

It looks “decent enough”, but when you try to implement it, everything goes wrong, full of bugs.

Many people think Claude isn’t capable, but the truth is: you didn’t let it think properly!

Claude’s Hidden Skill: Thinking Gear Adjuster

Claude Code actually has a built-in “thinking accelerator” tool (called Think Tool), but you have to trigger it yourself.

🧩 It supports 4 thinking levels:

Gear	Keywords	Thinking Token Limit	Thinking Depth
NONE	No keywords added	0 Tokens	Quick execution, almost no thinking
BASIC	think / 想	4K Tokens	Basic thinking, quick rough planning
MIDDLE	think hard / 好好想	10K Tokens	Moderate thinking, suitable for complex tasks
HIGHEST	ultrathink / 仔细思考	32K Tokens	Deepest thinking, suitable for tough challenges

This isn’t mysticism, but real settings written in Claude Code’s engineering code.

Add keywords, and it really will think for a while longer!

🎯Chinese Keywords Can Also Trigger

Don’t worry that Claude can’t understand Chinese, its trigger logic also supports our native language:

HIGHEST (32K): 仔细思考、深思、多想一会
MIDDLE (10K): 好好想、多想想
BASIC (4K): 思考、想

For example, if you say “Think carefully about this problem before giving me a plan” — Claude immediately switches to the highest gear, allocating the most thinking time!

Practical Advice: How to Use Most Effectively?

Of course, here are typical usage scenario examples for each thinking gear, concise and clear, ready to use directly 👇

🧠 ultrathink Example: Breaking Down Complex Product Features

Prompt: I want to develop a “Smart Daily Report Assistant” that can automatically aggregate today’s key events from Slack, Notion, GitHub, and help me generate daily report drafts. Please think carefully (ultrathink) about this problem first, then output a module division, data flow, and API interface design.

📌 Use Cases: Multi-system integration, vague requirements, need deep architectural thinking

🧠 think hard Example: Evaluating Multiple Technical Solutions

Prompt: I want to choose a database solution for a multi-user collaborative document application. Please think hard about whether to choose PostgreSQL + Redis or MongoDB + Kafka, output a comparative analysis and give recommendation reasons.

📌 Use Cases: Multiple routes available, need comparative analysis

🧠 think Example: Small Task Logical Planning

Prompt: I’m planning to write a script that downloads all image links from a Markdown file and renames them. Please think about how to do this first, which Python libraries are most suitable, then write the code for me.

📌 Use Cases: Task isn’t complex, just need a simple run-through of the approach

🧠 No Keywords Example: Direct Action

Prompt: I’ve already written the usage instructions for this AI summary tool. Please optimize the following text format into a README.md file, output the result directly, no need to overthink.

📌 Use Cases: Clear requirements, just need execution, no planning needed

🚀Recommended Usage Pattern: “Explore, Plan, Code, Commit”

Claude Code officially recommends a 4-step workflow:

Explore: Let Claude read files first, but don’t write code
Plan: Use ultrathink to make detailed plans (core step)
Code: Write code based on the plan, self-check reasonableness
Commit: Generate Pull Request and changelog

📌 Key Point: Step #2 Plan must add keywords to trigger “thinking gears”, otherwise it might skip deep thinking and start working directly!

🧠It’s Not That Claude Isn’t Smart, You Just Didn’t Let It Use Its Brain

Claude is very capable, but if you don’t give it “thinking space”, it can only respond hastily.

Use think, think hard, think harder, ultrathink well, and you can not only improve output quality but also solve complex problems in one go.

Do you think this design is clever? Have you ever fallen into the trap of “Claude starting work without thinking clearly”? Welcome to share your experience in the comments 👇

Run Claude Code on OpenAI-Compatible Models: A Hands-On Guide to claude-code-proxy

Jul 27, 2025

Vibe Sparking

claude-code-proxy automatically converts the Anthropic API used by Claude Code to an OpenAI-compatible API. In practice that means you can switch Claude Code to GPT-4o, Gemini, Ollama—or any OpenAI-style model—without touching your source code. You’ll cut costs and still keep function calling and streaming responses.

1. Why do we need this?

The stock Claude Code CLI only talks to Anthropic’s endpoint—it’s expensive and often rate-limited. A self-hosted proxy removes that bottleneck.
Plenty of “translation” scripts exist, but most don’t support function calling or smart model mapping, and they’re fiddly to configure.

2. Key Features

2.1 100 % API drop-in

Full support for /v1/messages, including on-the-fly conversion of Base64 images.

2.2 Switch between cloud and local models at will

Adapters for OpenAI, Azure OpenAI, Ollama and any other OpenAI-compatible service are built in.

2.3 Smart model mapping

haiku → SMALL_MODEL
sonnet → MIDDLE_MODEL
opus → BIG_MODEL

Flip one environment variable, done—no code edits.

2.4 Full function calling + SSE streaming

Claude Code continues to “write code, call APIs, stream output” on the new backend.

2.5 Robust error handling & logging

Timeouts or token overflows are caught and returned with human-readable messages.

3. Five-minute local setup

Commands below assume macOS/Linux

3.1 Install dependencies

# Super-fast with uv
uv sync
# Or the classic way
pip install -r requirements.txt

3.2 Copy and edit the environment file

cp .env.example .env
# Open .env and fill in OPENAI_API_KEY etc.

Required: OPENAI_API_KEY
Optional security gate: ANTHROPIC_API_KEY (requests must match if set).

3.3 Start the proxy

python start_proxy.py
# or uv run claude-code-proxy

Default listen address: 0.0.0.0:8082; default log level: WARNING.

3.4 Point Claude Code to the proxy

export ANTHROPIC_BASE_URL=http://localhost:8082
export ANTHROPIC_API_KEY=anything   # any string if the proxy doesn’t check
claude                              # Happy Vibe Coding!

4. Power-user tricks

✨ Hot-swap providers

Edit .env on the fly:

# Use Azure
OPENAI_BASE_URL="https://your-azure-endpoint"
BIG_MODEL="gpt-4"

# Use local Llama 3
OPENAI_BASE_URL="http://localhost:11434/v1"
BIG_MODEL="llama3.1:70b"

No need to restart Claude Code.

⚙️ Chain with a corporate proxy

Claude’s official client respects HTTP(S)_PROXY, so you can chain it with claude-code-proxy.

🏢 Roll out to multiple teams

Commit .env and docker-compose.yml to a private repo and spin up the proxy in CI.

5. Troubleshooting

401 Unauthorized – Ensure ANTHROPIC_API_KEY matches on both sides, or disable the check.
Model name not recognised – Verify it contains haiku/sonnet/opus, or set BIG_MODEL manually.
High latency – Enable GPU for local Ollama; in the cloud start uvicorn with --workers 4.

6. Wrap-up

With claude-code-proxy Claude Code becomes a true Swiss-army knife: Vue on the front end, Gemini on the back end, docs written with GPT-4o—all through one CLI port. Fire it up and tell me which model combo you like best!

Round-tripping PDFs with Claude Code

Jul 25, 2025

Vibe Sparking

Introduction

In daily work, contracts, agreements, BLE communication specifications… companies are never short of PDFs. They look beautiful but are a nightmare to edit: copy-paste gets messy, formatting goes haywire. This article shares a practical “reverse PDF → Markdown → PDF” workflow using Claude Code in three steps, while maintaining an editable Word version.

Why Go Through This Trouble?

Only PDF left, Word lost → Cannot maintain
Partners only accept PDFs → Format must be unified
Want to add new APIs/tables → Need text-editable format

Claude Code perfectly fills this gap.

Overall Workflow

PDF → Markdown (Editable) → Update → PDF/Word The core is leveraging Claude Code’s multimodal parsing and formatting capabilities.

① PDF ➜ Markdown

Goal: Preserve titles, tables, image references, convert to clean .md in one click.

Recommended Prompt

Please fully parse this PDF into Markdown:
1. Preserve all heading levels (#-###)
2. Display tables in Markdown syntax
3. Use `![alt](placeholder)` for images
4. Ignore footers and page numbers
Return complete Markdown text

Claude Code will automatically recognize the PDF structure and generate a clear Markdown document.

# CGM BLE Communication Protocol v2.1

## 1. Data Frame Structure
| Field       | Length(Byte) | Description           |
|-------------|-------------|-----------------------|
| Frame Head  | 2           | Fixed 0x55AA          |
| Length      | 1           | Subsequent byte length |
| Cmd         | 1           | Function code         |
| Payload     | N           | Business data         |
| CRC16       | 2           | Low byte first        |

![Frame Structure Diagram](fig/frame.svg)

> **Note**: All multi-byte fields are Little-Endian.

② Edit & Update Markdown

Goal: Add latest APIs, correct descriptions, make documentation live again.

Automatic Code Analysis

Please review this Markdown and find all API code blocks:
- Check for parameter naming consistency
- Mark potential errors and provide improvement suggestions

Claude Code will automatically analyze code blocks in Markdown, find potential issues, and suggest improvements.

Found 2 potential issues:
1. "Cmd=0x07 upload glucose" inconsistent with API list description (list says 0x08)
2. "CRC16 checksum algorithm" doesn't specify polynomial, could reference ITU-T X.25

Improvement suggestions:
- Update API list or correct documentation
- Add polynomial 0x1021 in <2.3 CRC Calculation> section

Or manually add details

### /device/sync

| Field   | Type | Required | Description            |
|---------|------|----------|------------------------|
| uid     | str  | Y        | Device unique ID       |
| ts      | int  | Y        | Unix timestamp(seconds)|
| glucose | int  | Y        | Current glucose(mg/dL) |

③ Markdown ➜ PDF

Goal: Output updated documentation as standard PDF for partner submission.

Recommended Prompt

Please render this Markdown as a beautifully formatted PDF:
- Use A4 pages
- Auto-generate table of contents from headings
- Center tables horizontally

Claude Code will generate a uniformly formatted PDF document.

Bonus: Generate Saveable Word Version

Need a Word version for the company? Use single-page HTML as a workaround!

Markdown ➜ Single-file HTML

Convert the following Markdown to self-contained (inline CSS) single-file HTML,
convenient for Word to open without dependencies.

Claude Code will generate an HTML file containing all styles.

<!DOCTYPE html><html><head>
<meta charset="utf-8">
<style>
body{font-family:"Microsoft YaHei";}
h1,h2{margin:1em 0;}
table{border-collapse:collapse;width:100%;}
td,th{border:1px solid #ccc;padding:6px;text-align:center;}
</style>
</head><body>
<h1>CGM BLE Communication Protocol v2.2</h1>
<h2>1. Data Frame Structure</h2>
<table>
<tr><th>Field</th><th>Length(Byte)</th><th>Description</th></tr>
<tr><td>Frame Head</td><td>2</td><td>Fixed 0x55AA</td></tr>
...
</table>
</body></html>

Then:

Word opens HTML → Save as DOCX/PDF
Get locally editable Word + final PDF, two birds with one stone.

Conclusion

Through Claude Code, bring out-of-control PDFs back to the editable world, then painlessly output standard PDF/Word, solving both “format unity” and “content maintainability” pain points.

What other stubborn PDFs do you have that need reviving? Leave a comment and chat—maybe the next article will cover your scenario!

Make Claude Code Smarter: Auto-Generate Six Spec Docs with the Specs Generator

Jul 23, 2025

Vibe Sparking

Tired of being led astray by “vibe-coding”?

This open-source tool Claude Code Specs Generator equips Claude Code with a “documentation generator” — automatically producing 6 core documents that clearly outline business, technology, architecture, and tasks, making Claude read the manual first before writing code.

Why — Why Write Specs First?

AI ≠ Mind Reading When context is messy, Claude often “takes liberties” rewriting dependencies or reinventing the wheel. Amazon’s Kiro IDE solved the same pain point with “Spec-Driven Development”, and practice proves: generating specs first, then code, dramatically reduces error rates.
Team Collaboration Saves 30% Communication Costs Unified product.md, tech.md, structure.md allow newcomers to complete code orientation in 10 minutes, reducing verbal handoffs.
Claude Reasoning More Accurate Include these 6 documents in CLAUDE.md, and AI loads them with every response, avoiding “memory gaps”.

How — How Does It Work?

1️⃣ Generate 6 Structured Files

Category	Specific Files	Purpose
Steering	product.md / tech.md / structure.md	Business goals, tech stack, directory standards
Specs	design.md / requirements.md / tasks.md	Architecture design, user stories, development tasks

System analyzes your repository & documentation, one-click /specs-create auto-generates everything.

2️⃣ Three Commands, Iterative Loop

/specs-create Initial spec creation
/specs-init Refresh context (auto /clear → /init)
/refresh-specs Incremental updates based on recent git commits

3️⃣ Seamless Integration with Claude Code

After specs are written, the generator writes file paths into CLAUDE.md. Next time you type @claude fix tests in terminal, Claude will reference the latest specs for execution.

What — What Can You Do With It?

New Project From Zero to One Pull an empty repository, run /specs-create, instantly get “product-tech-structure” three direction documents, then iterate design and tasks.
Legacy Project Governance Wrote lots of code and want to add documentation? Same one-click approach. The generator scans existing PRD/TODO files and merges content.
Continuous Delivery Trigger /refresh-specs CI script with every PR, letting specs evolve alongside code.

Quick Start

Installation
Terminal window
```
npx @kellemar/claude-code-specs-generator
```
- No global installation needed, creates .claude/ and specs/ directories in current project after execution.
One-Click Spec Generation
Terminal window
```
/specs-create
```
Parses code and old documentation, auto-generates 6 Markdown files and updates CLAUDE.md.
Load Context
Terminal window
```
/specs-init
```
Essentially /clear → /init combination, ensuring Claude carries latest Specs in every round.

After setup, your project will include:

your-project/
├── .claude/
│   └── steering/
│       ├── product.md      # Product vision and business goals
│       ├── tech.md         # Technology stack and constraints
│       └── structure.md    # Code organization patterns
├── specs/
│   ├── design.md          # Technical architecture
│   ├── requirements.md    # User stories and acceptance criteria
│   └── tasks.md          # Current development tasks
└── CLAUDE.md             # Updated with document references

Conclusion

Specs Generator = “Kiro-flavored” Free Plugin No need to switch to a new IDE, you can enjoy the security of spec-driven development in your existing Claude Code workflow. Try /npx @kellemar/claude-code-specs-generator now, and let both AI and humans take fewer detours!

🤔 Would you add it to your own project? Leave a comment and share which step you’d most like to automate!

(Next article we’ll break down how to turn Specs into Mermaid diagrams, stay tuned!)

Claude Code + Kimi K2: The 1‑Line Env Hack for AI Coding

Jul 22, 2025

Vibe Sparking

This article shows you how to use one environment variable to replace Claude Code in your terminal with Moonshot’s Kimi K2 — cheap, fast, and no need to “climb mountains”. Here’s the quick conclusion first, followed by step-by-step details that you can copy and follow.

Summary

Claude Code’s Agent workflow is incredibly satisfying, but by default it only connects to Anthropic’s official models, which is expensive and has network issues.
Kimi K2 publicly provides Anthropic-compatible API, starting at 0.02 yuan per 1k tokens, about an order of magnitude cheaper than the official version; long context and coding capabilities are also solid.
Just apply for a Moonshot API Key in advance and fill in ANTHROPIC_AUTH_TOKEN and ANTHROPIC_BASE_URL, and Claude Code will treat K2 as the “genuine Claude” without needing to modify source code or use proxies.

1 | Prerequisites

Required Software	Minimum Version
Node.js	18+
npm	8+
Git	2.20+

Verify with node -v in terminal. If below 18, please upgrade to LTS version.

Then install Claude Code globally:

npm install -g @anthropic-ai/claude-code
claude --version    # If you can see the version number, you're good

2 | Get Kimi K2 API Key

Visit Moonshot Console https://platform.moonshot.cn/console/api-keys, create a new Key (prefix sk-).

Copy and save it securely, as you won’t be able to view it again.

3 | One-Line Environment Variable Setup

Linux / macOS

export ANTHROPIC_AUTH_TOKEN=sk-your-key
export ANTHROPIC_BASE_URL=https://api.moonshot.cn/anthropic
claude            # Now all requests go through Kimi K2

Windows CMD

set ANTHROPIC_AUTH_TOKEN=sk-your-key
set ANTHROPIC_BASE_URL=https://api.moonshot.cn/anthropic
claude

TIP: For permanent effect, add the two export/set commands to ~/.bashrc, ~/.zshrc, or “System Environment Variables”.

4 | Verify It’s Working

Open a new terminal and run claude, then ask:

/status

If you see Anthropic Base URL: https://api.moonshot.cn/anthropic, it means you’re connected to K2. You can also have it write some code, and you’ll notice significant improvements in speed and cost.

Regularly check the Moonshot console to monitor K2 usage and costs.

5 | Common Issues & Troubleshooting

Symptom	Solution
”401 Unauthorized” error	Confirm that `ANTHROPIC_AUTH_TOKEN` has the `sk-` prefix and hasn’t expired.
Prompt to login to Anthropic	Add `export ANTHROPIC_API_KEY=NOT_NEEDED` to bypass the check.
Want to temporarily switch back to official Claude	`unset ANTHROPIC_BASE_URL`; set it back to reconnect to K2.
Proxy software conflicts	If you have proxy scripts running locally (like `kimi-cc`), ensure ports aren’t conflicting, or switch to the official direct connection method above.

6 | Cost & Performance Analysis

Moonshot K2: Input 1k tokens 0.02 yuan, output 0.06 yuan; at least 10× cheaper than official Claude Opus.
In practice, writing a small web game costs ≈ 0.6 yuan, truly “1 yuan outsourcing”.

7 | One-Line Summary

Turn the pain points of “expensive + network issues” into the sweet spot of “cost-effective + direct connection” — just two environment variables, and Claude Code instantly switches to Kimi K2, upgrading your terminal to a domestic large model engine.

Have fun, and don’t forget to type :set language zh in claude to make the AI speak Chinese too; more new tricks in the comments!

Claude Code Templates: One-Click Setup & Real-Time Monitoring for Your Claude Code

Jul 21, 2025

Vibe Sparking

claude-code-templates is an open-source CLI tool created by developer Daniel Avila (davila7), designed to help developers quickly configure and monitor Claude Code. It can generate project configurations with one click, analyze existing settings, and display runtime status in real-time, making it perfect for use with Claude Code .

Feature Highlights

1️⃣ Rapid Project Initialization

Supports JavaScript/TS (including React, Vue, Angular, Node.js), Python (Django, Flask, FastAPI), and generic templates. Other languages like Go and Rust are coming soon .
Supports interactive startup and can also achieve one-click configuration through parameters like --language, --framework, --yes, --dry-run, --directory .
Installation command: npx claude-code-templates@latest, no global installation required. Can also be installed globally: npm install -g claude-code-templates .

npx claude-code-templates@latest

 ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
██║     ██║     ███████║██║   ██║██║  ██║█████╗
██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝
╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
 ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝

 ██████╗ ██████╗ ██████╗ ███████╗
██╔════╝██╔═══██╗██╔══██╗██╔════╝
██║     ██║   ██║██║  ██║█████╗
██║     ██║   ██║██║  ██║██╔══╝
╚██████╗╚██████╔╝██████╔╝███████╗
 ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝

████████╗███████╗███╗   ███╗██████╗ ██╗      █████╗ ████████╗███████╗███████╗
╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██║     ██╔══██╗╚══██╔══╝██╔════╝██╔════╝
   ██║   █████╗  ██╔████╔██║██████╔╝██║     ███████║   ██║   █████╗  ███████╗
   ██║   ██╔══╝  ██║╚██╔╝██║██╔═══╝ ██║     ██╔══██║   ██║   ██╔══╝  ╚════██║
   ██║   ███████╗██║ ╚═╝ ██║██║     ███████╗██║  ██║   ██║   ███████╗███████║
   ╚═╝   ╚══════╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝

     🚀 Setup Claude Code for any project language 🚀
🚀 Welcome to Claude Code Templates!

? What would you like to do? (Use arrow keys)
❯ 📊 Analytics Dashboard - Monitor your Claude Code usage and sessions
  🔍 Health Check - Verify your Claude Code setup and configuration
  ⚙️ Project Setup - Configure Claude Code for your project

2️⃣ Real-Time Analytics Dashboard

Launch command --analytics, opens local dashboard (default http://localhost:3333), displaying Claude session count, token usage, session history, project activity, etc.
Supports CSV/JSON export, runs completely locally with no data leakage .
Reddit users comment: “Real-time monitoring … runs completely local (localhost:3333)… Token usage insights have been eye-opening!” .

3️⃣ Comprehensive Health Check

Use --health-check to verify system environment, Node.js version, network connectivity, Claude Code configuration, hooks, MCP, etc., providing visual check results and recommendations .

4️⃣ Analyze Commands, Hooks & MCP

Deep analysis can be performed through the following commands:

npx claude-code-templates --commands-stats
npx claude-code-templates --hooks-stats
npx claude-code-templates --mcps-stats

Commands output command file statistics, hook enable status, MCP service status, AI optimization suggestions, etc. .

5️⃣ Security & Rollback Protection

Supports dry-run mode to preview operations, automatically backs up existing configurations, prompts for confirmation before changes, and can be canceled at any time. --yes can skip prompts for automatic execution .

📦 Installation & Usage Guide

Quick Installation Setup

npm install -g claude-code-templates
npx claude-code-templates

Enter target project path, complete configuration in one step.

Non-Interactive Usage Example

npx claude-code-templates \
  --language javascript-typescript \
  --framework react \
  --yes

For Python + Django, use similarly: --language python --framework django --yes .

Run Dashboard

npx claude-code-templates --analytics

Check System Status

npx claude-code-templates --health-check

Command & MCP & Hook Analysis

npx claude-code-templates --commands-stats
npx claude-code-templates --hooks-stats
npx claude-code-templates --mcps-stats

✅ Why Use It?

Time and effort saving: What previously required manual configuration of .claude/, CLAUDE.md, commands, MCP, hooks, now takes just seconds.
Real-time visualization: Analytics Dashboard provides clear session monitoring and token usage at a glance.
Standards + Security: Automatic backup + dry-run + confirmation mechanism ensures project configuration safety.
Optimization suggestions: Command analysis and hook/MCP stats help you optimize and form best practices.

🧠 Community Feedback

Reddit users praise its Dashboard functionality:

“Real-time monitoring of all Claude Code sessions… Token usage charts and project activity breakdown… runs completely local” .

The community is also hotly discussing new feature requests, such as support for SwiftUI project templates .

Additionally, the author just launched an online template preview page where users can browse templates through the web, copy installation commands, and contribute their own templates to the community .

🚀 Summary & Outlook

claude-code-templates is summed up in one sentence: Make Claude Code “ready-to-use, monitorable, and optimizable.” Suitable for teams or individuals who pursue efficient development workflows, like dashboard views, and value configuration security. Next, the project will support more languages/frameworks like Go and Rust, and open up online community template submission portals to build the ecosystem together.

Hope this article helps you quickly understand and get started with claude-code-templates, making your Claude Code development more relaxed, visual, and professional. Open your terminal and try:

npx claude-code-templates --analytics

Start a smarter development journey ✨

Sniffly: Visualizing Your Claude Code Usage Patterns with Dashboards

Jul 17, 2025

Vibe Sparking

One command to instantly transform boring Claude Code jsonl logs into visual insights.

1️⃣ What is Sniffly?

Sniffly is a local tool open-sourced by Chip Huyen that specifically parses .jsonl logs generated by Claude Code and creates an interactive web dashboard, helping you quickly answer three questions:

What you want to know…	Sniffly provides…
What did I actually use Claude Code for?	Usage Stats: command counts, file operations, average steps, etc.
What errors does Claude Code make most often?	Error Breakdown: visualize errors by type and percentage
Why did a certain conversation go wrong?	Message History: replay complete context step by step

All calculations are done locally without uploading any conversations or code, privacy-friendly.

2️⃣ Quick Start (3 Steps)

Environment requirements: Python 3.10+

# ✅ Temporary trial (no installation required)
uvx sniffly@latest init

# ✅ Global installation
uv tool install sniffly@latest   # or  pip install sniffly
sniffly init                     # First scan and start service

By default, it opens the dashboard at http://localhost:8081 in your browser. You can also change the port or disable auto-open via command line:

sniffly config set port 8090
sniffly config set auto_browser false

3️⃣ Core Features Overview

Feature	Highlights
Usage Stats	Bar charts/line graphs for command counts, conversation length, average steps, most time-consuming commands, etc.
Error Breakdown	Statistics for `FileNotFound`, `FuncNotFound`, `Timeout` and other error percentages
Message History	Like a “recording tape” replay, synchronously showing your code diffs
Sharable Dashboard	One-click generation of private/public links to share insights with teammates

4️⃣ Insights I Got from Sniffly

Chip Huyen shared two surprising discoveries in her launch post:

“Content Not Found” is the most common error, accounting for 20-30% —— Claude Code often looks for non-existent files/functions.
After optimizing project structure, average command steps dropped from 8 to 7 —— Just improving discoverability had immediate efficiency gains.

Similarly, you can use Sniffly to find your own “invisible efficiency black holes” and make targeted improvements.

5️⃣ Advanced Usage

Goal	Command / Operation
Switch project directory to analyze	`sniffly init --project /path/to/project`
Limit memory usage	`sniffly config set cache_max_mb_per_project 200`
Share stats only, hide command text	Dashboard ▶︎ Share ▶︎ check Hide Commands
Align logs & Git commit timeline	Pass git repo path to `sniffly init`, timeline auto-merges

6️⃣ Summary

If you’re also using Claude Code for Vibe Coding but struggling with:

Scattered logs, hard to focus on issues
Many error types, don’t know what to optimize first
Want to show AI programming ROI to your team but lack visual evidence

Then try Sniffly —— One command to help you “sniff out” the value hidden in logs.

Open source address, documentation, and demo:

GitHub: https://github.com/chiphuyen/sniffly
Official site: https://sniffly.dev/

Take action! Let Sniffly become your Claude Code “black box,” starting today to quantify every gain and loss in AI programming.

Claude Code Alternative: DeepSeek R1 + Kimi K2 Quick Start Guide

Jul 16, 2025

Vibe Sparking

Claude Code Router (CCR) https://github.com/musistudio/claude-code-router is a “multi-model router” tailored for Claude Code users: it listens locally to Claude Code’s standard requests, then forwards them to DeepSeek-R1, Kimi K2, and any other LLMs according to your routing strategy. It’s compatible with OpenAI-style APIs and can add “transformers” for different models to adapt parameters and responses. This article first provides an overview of CCR’s core mechanisms, then demonstrates step-by-step how to integrate DeepSeek R1 and Kimi K2, giving you everything you need for “multi-model collaborative coding.”

1 | What Can CCR Do?

1.1 Core Concept

CCR describes Provider → Model → Transformer → Routing Rules through ~/.claude-code-router/config.json, allowing Claude Code to hot-switch backend models in VS Code/terminal as usual using /model.
Built-in pluggable transformers for DeepSeek, OpenRouter, Gemini, MaxToken, etc., allowing multiple transformations to be stacked on a single model.
Supports both CLI and GitHub Actions modes; combined with Actions, you can leverage DeepSeek’s 25% nighttime rates for “early morning batch processing.”

1.2 Quick Installation

npm i -g @anthropic-ai/claude-code     # Install Claude Code
npm i -g @musistudio/claude-code-router
ccr code                               # Start Claude Code with CCR

2 | Integrating DeepSeek R1

2.1 Prepare API Key

Apply for a key in the DeepSeek Platform console and record the sk-xxx.
The official API is https://api.deepseek.com/chat/completions, fully compatible with OpenAI SDK.
R1 latest version number deepseek-r1-250528 (VolcEngine mirror provides 128K context).

2.2 Modify CCR Configuration

{
  "Providers": [
    {
      "name": "volcengine",
      "api_base_url": "https://ark.cn-beijing.volces.com/api/v3/chat/completions",
      "api_key": "sk-your-key",
      "models": ["deepseek-r1-250528"],
      "transformer": { "use": ["deepseek"] }
    }
  ],
  "Router": {
    "think": "volcengine,deepseek-r1-250528"
  }
}

The deepseek transformer automatically limits max_tokens to 8192 and is compatible with R1’s lack of tool_choice support.
Nighttime (00:30 – 08:30 UTC+8) R1 calls cost only 25% of daytime rates → suitable for large-scale testing/refactoring scripts.

2.3 CLI Dynamic Switching

Type in Claude Code:

/model volcengine,deepseek-r1-250528

This immediately switches the next conversation to use DeepSeek R1, inheriting the 128K context window.

3 | Integrating Kimi K2

3.1 Why Choose K2?

Moonshot AI’s latest open-source MoE model, 1T total parameters / 32B activated experts, excelling at code generation and agent calls.
SiliconFlow provides 16384 max_tokens quota with high-concurrency, low-latency inference services, suitable for long-chain code analysis.

3.2 Get Key

Enter siliconflow.cn console, enable moonshotai/Kimi-K2-Instruct and get the token.
Can also use OpenRouter’s unified compatible endpoint https://openrouter.ai/api/v1/chat/completions.

3.3 Configuration Example

{
  "Providers": [
    {
      "name": "siliconflow",
      "api_base_url": "https://api.siliconflow.cn/v1/chat/completions",
      "api_key": "sk-your-token",
      "models": ["moonshotai/Kimi-K2-Instruct"],
      "transformer": {
        "use": [
          ["maxtoken", { "max_tokens": 16384 }]
        ]
      }
    }
  ],
  "Router": {
    "longContext": "siliconflow,moonshotai/Kimi-K2-Instruct"
  }
}

The maxtoken transformer prevents CCR from accidentally exceeding SiliconFlow’s 16K max_tokens limit.
If you want to feed K2 all 32K+ project documentation in the same session, first use /model siliconflow,moonshotai/Kimi-K2-Instruct, then paste the full text.

3.4 Call Effect

SiliconFlow’s official cURL examples only need to replace with CCR’s local port; CCR handles forwarding and field compatibility.

4 | Practical Tips

Scenario	Router Key	Recommended Model
Bulk File Refactoring	`think`	DeepSeek-R1 (low cost + reasoning chain output)
Ultra-long Project README Summary	`longContext`	Kimi-K2 (16K context)
Nighttime Offline CI	GitHub Actions + CCR	DeepSeek-R1 (25% nighttime rates)
Local Inference/Offline Background Tasks	`background`	qwen-coder-2.5@Ollama (0 cost)

CCR’s /model provider,model command supports hot-switching anytime; you can also preset default models for different task channels in Router, achieving a pipeline of “use R1 for coding, use K2 for long text reading.”

5 | Common Pitfalls & FAQ

Slow response? DeepSeek’s official endpoint inference is relatively slow. If VS Code times out, enable UltraThink budget or switch to VolcEngine mirror.
Context overflow? DeepSeek API defaults to 64K, the above example uses VolcEngine to expand to 128K; Kimi K2 is 16K, needs maxtoken protection.
Wrong model name? CCR’s /model format must be provider,model, don’t forget the comma.
Tool calls failing? R1 currently doesn’t support tool_choice. For function calls, fall back to DeepSeek V3, or add a tooluse transformer to V3 in CCR.

With Claude Code Router + DeepSeek R1 + Kimi K2, you can hot-switch between “reasoning power” and “long context” strengths in the same IDE: use K2 for long document reports during the day, switch to R1 for batch code migration at night, at less than one-tenth the cost of official Claude Max. Install CCR now and unlock your new multi-model coding experience!

Claude Code Development Tool: `claude-trace` Complete Recording Tool for Transparent Debugging

Jul 12, 2025

Vibe Sparking

When using Claude Code to write code, have you ever wondered:

How does Claude understand your instructions?
What exactly is written in the system prompt?
What tools did Claude use? What raw data was returned?
What happens behind the API? How many tokens did the model use?

Now, with the open-source tool claude-trace, you can see all these “behind-the-scenes” details!

📦 Installation

Install with just one command:

npm install -g @mariozechner/claude-trace

🚀 One-Click Start Logging

Start Claude Code and record the entire process:

claude-trace

Supports more options:

Feature	Command
Start Claude + logging	`claude-trace`
Include all requests (default only logs valid conversations)	`claude-trace --include-all-requests`
Run Claude with specific parameters	`claude-trace --run-with chat --model sonnet-3.5`
Extract OAuth token	`claude-trace --extract-token`
Generate HTML session report	`claude-trace --generate-html logs.jsonl report.html`
Auto-generate index + summary	`claude-trace --index`

🔍 What Can You See?

Using claude-trace, you can see in the generated HTML page:

✅ Claude’s system prompt (hidden instructions)
✅ All raw API request and response data
✅ Tool definitions and outputs (like search/file reading)
✅ Claude’s “thinking process” blocks
✅ Token usage statistics (including cache hit situations)
✅ Interactive HTML view + search index
✅ JSONL raw logs (saved in .claude-trace/ folder)

Each run generates a self-contained HTML file, viewable locally without a server, perfect for team reviews, debugging, and archiving.

📊 Session Summary & Index Features (AI-Enhanced)

Through the claude-trace --index command, you can also auto-generate:

AI-generated summary titles and overviews for all logs
Indexed index.html file
Clickable historical session list

Manage all Claude conversation records like managing Notion!

🧑‍💻 Who Is This For?

If you match these tags, you’ll love it:

💡 Deep users or plugin developers of Claude Code
🧪 Need to debug Claude tool chains, system instructions, or log structures
📁 Want to archive all Claude programming sessions
🧠 Want to understand Claude’s real “thinking” process behind the scenes
⚙️ Need to build automated testing or generate session review reports

🌐 Open Source Repository

Project repository: https://github.com/mariozechner/claude-trace

Summary:

claude-trace is an essential debugging tool for Claude Code users, letting you see inside the AI’s “black box.” Whether developing plugins, analyzing model responses, or building Claude engineering log systems, it brings tremendous convenience.

If you’re developing projects with Claude, give it a try and start your “Claude visual development journey” with one click!

Hands‑On with Vibe Kanban: Manage Claude, Gemini & Amp Tasks in One Board

Jul 12, 2025

Vibe Sparking

Coding Agents (like Claude Code, Gemini CLI, Amp, etc.) are becoming increasingly important in engineering development. Teams are finding that the time spent on planning, reviewing, and coordinating these human tasks now exceeds the time spent writing code itself.

Vibe Kanban https://github.com/BloopAI/vibe-kanban is a new tool specifically designed to solve these collaboration workflow problems. Through its Kanban board interface, it allows you to:

Quickly switch between coding agents (Claude, Gemini, Amp, etc.);
Call multiple agents in parallel or series, automatically executing tasks;
Visualize task status, code reviews, and quickly launch Dev Servers;
Centrally manage agent MPC configurations to improve overall collaboration efficiency;
In the future, coding agents will be able to automatically create task tickets through MCP servers.

Vibe Kanban’s design philosophy is: When most code is written by AI, our human role becomes planning, reviewing, and coordinating. This is not just a trend, but a completely new way of development work.

⚙️ Installation + Launch Guide

Pre-configure Agents For example, install and log into Claude Code, Gemini CLI, Amp, etc.
Run command to start Vibe Kanban
Terminal window
```
npx vibe-kanban
```
Automatically finds local port and opens browser (e.g., http://127.0.0.1:53046), entering the Kanban workspace.
Configure Agents Initially, you need to add Agent MCP in Settings (e.g., Claude, Gemini, Amp tokens/paths), then you can freely switch agents in the UI to execute tasks.
Create Project Create a new project in the Kanban interface, add Tasks, and you can start using it.

📌 Core Features Explained

1. Multi-Agent Parallel or Serial Task Execution

After switching to the corresponding agent, you can initiate multiple “Attempts” for the same task. Supports parallel execution (different branches/workspaces) and serial execution (waiting for the previous step to complete before proceeding). Execution status and logs are clear at a glance.

2. Quick Review and Dev Server Launch

After each agent generates code, Vibe Kanban automatically displays diffs and execution output, providing a one-click Dev Server launch button for real-time preview.

3. Visual Task Flow Management

Uses the common three-column Kanban layout (To Do, In Progress, Done), providing an intuitive view of task status and agent execution progress. You can create multiple attempts for a task and mark them as success/failure.

4. Centralized Agent MCP Configuration

All agent configurations (e.g., Claude, Gemini tokens, run commands, etc.) are centrally managed in the Settings interface, making switching seamless.

5. Automatic Ticket Creation by Agents (MCP Integration)

Vibe Kanban has a built-in “Vibe Kanban MCP” server plugin that can automatically generate planner tickets through agents. For example:

“Plan a migration from AWS to Azure and create detailed tickets…” The agent will automatically break down tasks and create multiple Kanban cards, all done in the UI without manual intervention.

💼 A Typical Workflow Example

Create a task in Kanban: e.g., “Implement user login page”;
Select an agent (like Claude Code), click “New Attempt”;
Agent automatically generates login page components and backend interfaces;
You review the differences, run Dev Server, and verify the UI;
If issues are found, modify instructions for the agent to retry, or re-select an agent (like Gemini);
Mark the attempt as successful and move the task to Done.

The entire process requires no switching between command line windows, everything is operated within the UI, efficient and intuitive.

For individual developers: Greatly improves task startup, review, and debugging efficiency, making development smoother and more structured.
For small team collaboration: Agents automatically break down tasks, multiple attempts collaborate to complete, with independent Git worktrees, can connect to external MCP, suitable for team pipeline collaboration.
Investing in future capabilities: As agent capabilities continue to improve, Vibe Kanban can seamlessly adapt to different agents, allowing you to experience the latest model capabilities at any time.

⏳ Epilogue: AI is Coding, We are Collaborating

Vibe Kanban is pioneering the new paradigm of “Agent-driven, human-orchestrated”. From the era of writing code to the era of orchestrating and reviewing code, we will unleash human creativity and make Agent Handoff more efficient with clearer processes. We recommend all developers who are testing or using coding agents in production to give it a try.

🎯 ccusage: Analyze Claude Code Usage Analytics

Jul 10, 2025

Vibe Sparking

ccusage is a command-line tool created by open-source developer ryoppippi for analyzing locally generated JSONL files from Claude Code. It displays your token usage and corresponding costs through visual tables, helping you better manage usage habits and cost structures.

Simple functionality: Get daily, monthly, session, and billing block (5-hour) level token usage and cost distribution with just one command.
Real-time monitoring: Supports blocks --live for real-time monitoring of consumption rates and project progress within the current billing block.
Lightweight and efficient: Extremely small size (npm package ~1 MB), no dependency installation required, suitable for quick analysis.

🧩 Use Cases

Cost awareness While Claude Code’s Max version offers unlimited usage, when switching to pay-per-use plans, ccusage can help you estimate daily and monthly costs, considering your “pain-free threshold.”
Daily data tracking Through daily or monthly reports, timely grasp long-term token usage trends and identify any sudden spikes or anomalies.
Session/billing block monitoring
- Session level: Analyze single conversation token usage distribution and costs corresponding to projects and topics.
- Block monitoring: Track consumption trends and rates within five-hour billing cycles (add --live for real-time observation).
Multi-terminal sync analysis ccusage defaults to reading JSONL files from ~/.config/claude/projects/ and legacy path ~/.claude/projects/, enabling unified multi-device data analysis with cloud sync.
Secondary visualization and tool integration Provides JSON output for integration with tools like Raycast, Neovim plugins, Go or Rust versions of real-time visualization tools (such as ccusage.nvim, ccusage-monitor, etc.).

⚙️ Installation & Quick Start

No installation required, recommended to use execution environment directly:

# Recommended bunx (extremely fast)
bunx ccusage

# Or npx
npx ccusage@latest

# Or Deno
deno run -E -R=$HOME/.claude/projects/ -S=homedir -N='raw.githubusercontent.com:443' npm:ccusage@latest

Can also install globally:

npm install -g ccusage
# or
bun install -g ccusage

🚀 Core Command Examples

# Display default "daily" usage report:
ccusage

# Specify daily, monthly, session, or billing block reports:
ccusage daily
ccusage monthly
ccusage session
ccusage blocks

# Real-time monitoring of current billing block status:
ccusage blocks --live

More common parameters:

--since / --until: Analyze only specified date ranges
--breakdown: Show detailed consumption by models (like Opus, Sonnet)
--json: Output structured JSON for easy integration with other tools

📊 Example Analysis New

Running ccusage daily outputs something like:

Quickly see daily total tokens, cache hit counts, and estimated costs.

Using ccusage blocks --live, the console will refresh in real-time showing current billing block accumulated tokens, burn rate, remaining budget, etc., like a CLI version “htop”.

🛡️ Notes & Tips

Cost estimates are simulated values: ccusage displays estimated costs based on token quantities and model pricing, which may slightly differ from actual bills.

✍️ Summary

ccusage is a compact but powerful CLI tool, suitable for developers and heavy users:

Quickly get daily/session/billing segment token consumption and cost analysis;
Real-time monitoring of current billing block progress;
Seamless integration with Raycast, Neovim, Go/Rust tools;
Cross-device analysis only requires syncing JSONL files.

Try npx ccusage daily and you’ll be surprised by your “spending trajectory” in Claude Code usage, becoming more conscious about budget management. Follow our channel to explore more efficiency secrets in the Claude ecosystem!

📌 Finally, if you want to learn more AI, Vibe Coding, and Claude usage tips, integration plugin recommendations, or advanced analysis, welcome to leave comments for discussion. Let’s build a smarter AI usage experience together!

Claude Code

CLIProxyAPI: Transform Your AI Subscriptions into Universal API Endpoints

Introduction

What is CLIProxyAPI?

Key Features and Highlights

1. Multi-Provider OAuth Integration

2. Universal API Compatibility

3. Advanced Account Management

4. Comprehensive Feature Set

Prerequisites, Installation and Configuration

System Requirements

Installation Methods

Method 1: Build from Source

Method 2: Docker Deployment

Method 3: Pre-built Binaries

Quick Configuration

Recommended Scenarios and Best Practices

Use Case 1: AI Coding Tool Integration

Use Case 2: Multi-Account Load Balancing

Use Case 3: Cost Optimization

Best Practices

Ecosystem and Related Projects

Comparison with Similar Tools

vs. Direct API Keys

vs. Other Proxy Solutions

Precautions, FAQ and Troubleshooting

Common Issues

Security Considerations

Troubleshooting Tips

Reference Links

Conclusion

Introduction

What is CodMate?

Key Features

Lightning-Fast Search & Navigation

Project & Task Organization

Terminal Integration

Project Review (Git Changes)

MCP Server Management

Installation

Download

Prerequisites

Architecture & Performance

Keyboard Shortcuts

Comparison with Alternatives

Use Cases

1. Finding That Perfect Solution

2. Project Continuity

3. Code Review Before Commit

Precautions & Limitations

Known Limitations

Storage Locations

FAQ

Development & Contributing

Building from Source

Conclusion

Reference Links

Introduction

Key Features and Highlights

🤖 Direct Agent Integration

📝 Note Mentions

⚡ Slash Commands

🔄 Multi-Agent Support

🎛️ Mode & Model Selection

💻 Terminal Integration

🖼️ Image Attachments

🔐 Permission Management

Supported Agents

Prerequisites and Installation

Prerequisites

Installation

Method 1: Via BRAT (Recommended)

Method 2: Manual Installation

Configuration

Step 1: Install Agent Dependencies

Step 2: Find Installation Paths

Step 3: Configure Plugin Settings

Example Configuration (macOS/Linux):

Recommended Scenarios and Best Practices

Daily Workflow Integration

Team Knowledge Base: Shared `CLAUDE.md` in Git

Code Review Integration: `@.claude` PR Tags